home *** CD-ROM | disk | FTP | other *** search
/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / share / catman / p_man / cat3 / il_c / ilImage.z / ilImage
Encoding:
Text File  |  2002-10-03  |  138.8 KB  |  2,706 lines
  1.  
  2.  
  3.  
  4. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      iiiillllIIIImmmmaaaaggggeeee - base class for the ImageVision Library toolkit
  10.  
  11. IIIINNNNHHHHEEEERRRRIIIITTTTSSSS FFFFRRRROOOOMMMM
  12.      ilLink
  13.  
  14. HHHHEEEEAAAADDDDEEEERRRR FFFFIIIILLLLEEEE
  15.      #include <il/ilCdefs.h>
  16.  
  17. CCCCLLLLAAAASSSSSSSS DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  18.      ilImage is the base class for the ImageVision Library (IL) toolkit. All
  19.      IL image objects are derived from ilImage either directly or indirectly.
  20.      The ilImage base class abstracts the general concept of an image by
  21.      defining variables and functions common to all images. It defines image
  22.      parameters (e.g. size, data type), and provides access functions to query
  23.      and set them. It also provides functions to access image data. ilImage is
  24.      derived from ilLink so that images can be chained together, which allows
  25.      the output of one image operation to become the input to another.
  26.  
  27.      ilImage thus defines a common Application Program Interface (API).  This
  28.      means that, for example, image data can be obtained from any image object
  29.      by calling iiiillllGGGGeeeettttTTTTiiiilllleeee()
  30.  
  31.      UUUUssssiiiinnnngggg iiiillllIIIImmmmaaaaggggeeee
  32.  
  33.      ilImage is intended to be used as a base class for deriving new types of
  34.      images.  Because most of the image data access virtuals return the status
  35.      ilUNSUPPORTED, it is not useful to directly construct an ilImage object.
  36.      However, a pointer to an ilImage can be declared to reference an image of
  37.      unknown derivation.
  38.  
  39.      The ilImage class provides protected and public member functions. The
  40.      protected functions provide convenient services to derived classes,
  41.      (particularly for initializing and resetting an image's attributes) while
  42.      the public functions form the API.
  43.  
  44.      QQQQuuuueeeerrrryyyyiiiinnnngggg aaaannnndddd SSSSeeeettttttttiiiinnnngggg IIIImmmmaaaaggggeeee AAAAttttttttrrrriiiibbbbuuuutttteeeessss
  45.  
  46.      The size of an image in the _x, _y, _z and _c dimensions can be retrieved
  47.      using the function, iiiillllGGGGeeeettttSSSSiiiizzzzeeee().  In a typical 2-D image, z is 1 and the
  48.      number of channels (c) per pixel is 3 (red, green and blue, for example).
  49.      The image size is stored in a data object called iflSize. The size of the
  50.      image can be set using the function, iiiillllSSSSeeeettttSSSSiiiizzzzeeee().
  51.  
  52.      The data type of the pixel channels can be retrieved using the function,
  53.      iiiillllGGGGeeeettttDDDDaaaattttaaaaTTTTyyyyppppeeee().  It returns an enumerated type called _i_f_l_D_a_t_a_T_y_p_e, which
  54.      has members _i_f_l_C_h_a_r, _i_f_l_U_C_h_a_r, _i_f_l_F_l_o_a_t, and so forth.  The data type can
  55.      be set by passing an iflDataType to the member function, iiiillllSSSSeeeettttDDDDaaaattttaaaaTTTTyyyyppppeeee().
  56.  
  57.      The pixel channel order can be queried and set using iiiillllGGGGeeeettttOOOOrrrrddddeeeerrrr() and
  58.      iiiillllSSSSeeeettttOOOOrrrrddddeeeerrrr(), respectively. This information is indicated with the
  59.      enumerated type, _i_f_l_O_r_d_e_r. _i_f_l_O_r_d_e_r has members _i_f_l_I_n_t_e_r_l_e_a_v_e_d,
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  71.  
  72.  
  73.  
  74.      _i_f_l_S_e_q_u_e_n_t_i_a_l and _i_f_l_S_e_p_a_r_a_t_e, which indicate how the pixel components
  75.      are stored.
  76.  
  77.      The orientation of an image can be queried and set using
  78.      iiiillllGGGGeeeettttOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn() and iiiillllSSSSeeeettttOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn(), respectively. The orientation
  79.      of an image is specified using the enumerated type, _i_f_l_O_r_i_e_n_t_a_t_i_o_n.  An
  80.      orientation of _i_f_l_L_o_w_e_r_L_e_f_t_O_r_i_g_i_n, for example, means that the origin of
  81.      the image is displayed in the lower left corner of the window.
  82.  
  83.      The color model of an image can be queried and set using
  84.      iiiillllGGGGeeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll() and iiiillllSSSSeeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll() functions, respectively.  The
  85.      color model can be one of the enumerated iflColorModel types.
  86.  
  87.      A color map can also be associated with an ilImage.  The color map can be
  88.      queried and set using the iiiillllGGGGeeeettttCCCCoooolllloooorrrrmmmmaaaapppp(), iiiillllGGGGeeeettttCCCCoooolllloooorrrrmmmmaaaappppPPPPttttrrrr and
  89.      iiiillllSSSSeeeettttCCCCoooolllloooorrrrmmmmaaaapppp() functions, respectively.  The color map is defined by
  90.      using an iflColormap object.
  91.  
  92.      In general, for each image attribute there are access functions to set or
  93.      get the associated member variables in class ilImage.
  94.  
  95.      AAAAcccccccceeeessssssssiiiinnnngggg IIIImmmmaaaaggggeeee DDDDaaaattttaaaa
  96.  
  97.      Image data can be accessed as pixels or as a rectangular region of
  98.      arbitrary size called a tile.  Both 2-D and 3-D tile access functions are
  99.      provided.
  100.  
  101.      The virtual access functions present a queued request model, which allows
  102.      an application to issue non-blocking requests for image I/O and later
  103.      inquire the status and/or wait for the operation to complete.  The queued
  104.      model also provides derived classes with the "hooks" needed to
  105.      automatically distribute operations across multiple processors. These
  106.      queued functions are distinguished by the prefix 'q' on the function
  107.      name.  For convenience, there are access functions which do wait for
  108.      their operation to complete, hiding the details of the queued model.
  109.  
  110.      There are several different functions to read image data, all based on
  111.      iiiillllQQQQGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD().  Similarly, there are several different functions to
  112.      write image data based on iiiillllQQQQSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD().  Two fast-paths called
  113.      iiiillllQQQQCCCCooooppppyyyyTTTTiiiilllleeeeCCCCffffgggg() and iiiillllQQQQCCCCooooppppyyyyTTTTiiiilllleeee3333DDDD() are available for copying a tile
  114.      from another ilImage.
  115.  
  116.      When calling the base functions listed above, the caller must specify the
  117.      origin (x, y, z) and size (nx, ny, nz) of the desired tile.  For 2-D
  118.      operations, z is set to 0 and nz is set to 1.  For pixel operations, nx,
  119.      ny and nz are set to 1.  An object called iflConfig, is used to specify
  120.      the configuration (that is, data type, order, number of channels and so
  121.      forth) of the desired tile.  If required, the image data is converted to
  122.      a specified configuration while getting a tile, or converted from a
  123.      specified configuration to that of the image while setting a tile.
  124.  
  125.      CCCChhhhaaaaiiiinnnniiiinnnngggg IIIImmmmaaaaggggeeeessss
  126.  
  127.  
  128.  
  129.                                                                         PPPPaaaaggggeeee 2222
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  137.  
  138.  
  139.  
  140.      Images can be chained together, allowing the output from one image
  141.      operation to become the input to another image operation without an
  142.      intermediate buffer.  Each image can have multiple parents (inputs) and
  143.      multiple children (outputs). In addition to the functions inherited from
  144.      _i_l_L_i_n_k, several functions such as iiiillllSSSSeeeettttIIIInnnnppppuuuutttt(), iiiillllAAAAddddddddIIIInnnnppppuuuutttt() and
  145.      iiiillllRRRReeeemmmmoooovvvveeeeIIIInnnnppppuuuutttt() are also provided to manage the input list.  Inputs are
  146.      usually added to an image in its constructor, although the input list can
  147.      be manipulated after the image has been created.
  148.  
  149.      The power of chaining is fully realized with image operators (see the
  150.      ilOpImg man page), which can be chained together to perform complex image
  151.      processing operations.  Chaining also allows a single image to be an
  152.      input to multiple output operators.
  153.  
  154.  
  155. CCCCLLLLAAAASSSSSSSS MMMMEEEEMMMMBBBBEEEERRRR FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN SSSSUUUUMMMMMMMMAAAARRRRYYYY
  156.      DDDDeeeessssttttrrrruuuuccccttttoooorrrr
  157.  
  158.           void ilImageDelete(ilImage *img)
  159.  
  160.  
  161.      MMMMaaaannnniiiippppuuuullllaaaattttiiiinnnngggg iiiimmmmaaaaggggeeee iiiinnnnppppuuuuttttssss
  162.  
  163.           int ilGetNumInputs(ilImage *img)
  164.           ilStatus ilSetInput(ilImage *img, ilImage *inimg,
  165.                                       int idx)
  166.           ilStatus ilAddInput(ilImage *img, ilImage *inimg)
  167.           ilImage *ilGetInput(ilImage *img, int idx)
  168.           ilStatus ilRemoveInput(ilImage *img, int idx)
  169.           ilImage* ilGetDirectInput(ilImage *obj, int idx)
  170.  
  171.  
  172.      SSSSttttoooorrrriiiinnnngggg aaaannnndddd rrrreeeettttrrrriiiieeeevvvviiiinnnngggg 3333DDDD iiiimmmmaaaaggggeeee ddddaaaattttaaaa
  173.  
  174.           ilStatus ilGetSubTile3D(ilImage *img, int x, int y,
  175.                                   int z, int nx, int ny, int nz,
  176.                                   void *data, int dx, int dy, int dz,
  177.                                   int dnx, int dny, int dnz, ilConfig *config)
  178.  
  179.           ilStatus ilQGetSubTile3D(ilImage *obj, ilMpNode* parent,
  180.                                int x, int y, int z,
  181.                                int nx, int ny, int nz,
  182.                                void** data, int dx, int dy, int dz,
  183.                                int dnx, int dny, int dnz,
  184.                                const ilConfig* config, ilMpManager** pMgr)
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.                                                                         PPPPaaaaggggeeee 3333
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  203.  
  204.  
  205.  
  206.           ilStatus ilSetSubTile3D(ilImage *img, int x, int y,
  207.                                   int z, int nx, int ny, int nz, const void *data,
  208.                                   int dx, int dy, int dz, int dnx, int dny,
  209.                                   int dnz, ilConfig *config)
  210.  
  211.           ilStatus ilQSetSubTile3D(ilImage *obj, ilMpNode* parent,
  212.                                int x, int y, int z,
  213.                                int nx, nt ny, int nz,
  214.                                void* data, int dx, int dy, int dz,
  215.                                int dnx, int dny, int dnz,
  216.                                const ilConfig* config, ilMpManager** pMgr)
  217.  
  218.           ilStatus ilCopyTileCfg(ilImage *img, int x, int y, int z,
  219.                                 int nx, int ny, int nz, ilImage *other, int ox,
  220.                                 int oy, int oz, ilConfig *config)
  221.  
  222.           ilStatus ilQCopyTileCfg(ilImage *obj, ilMpNode* parent,
  223.                               int x, int y, int z,
  224.                               int nx, int ny, int nz,
  225.                               ilImage* other, int ox, int oy, int oz,
  226.                               const ilConfig* config, ilMpManager** pMgr)
  227.  
  228.           ilStatus ilFillTile3D(ilImage *img, int x, int y, int z, int nx,
  229.                                 int ny, int nz, void *data, ilConfig *config,
  230.                                 iflTile2Dint *fillMask)
  231.  
  232.           ilStatus ilQFillTile3D(ilImage *obj, ilMpNode* parent,
  233.                              int x, int y, int z,
  234.                              int nx, int ny, int nz,
  235.                              const void* data, const ilConfig* config,
  236.                              const iflTile3Dint* fillMask,
  237.                              ilMpManager** pMgr)
  238.  
  239.           ilStatus ilImageFillTileRGB(ilImage *obj, int x, int y, int z,
  240.                                       int nx, int ny, int nz,
  241.                                       float red, float green, float blue,
  242.                                       const iflTile3Dint* fillMask,
  243.                                       iflOrientation orientation)
  244.  
  245.           ilStatus ilQFillTileRGB(ilImage *obj, ilMpNode* parent,
  246.                               int x, int y, int z, int nx, int ny, int nz,
  247.                               float red, float green, float blue,
  248.                               const iflTile3Dint* fillMask,
  249.                               iflOrientation orientation,
  250.                               ilMpManager** pMgr)
  251.  
  252.           ilStatus ilCopyTile3D(ilImage *img, int x, int y, int z,
  253.                                 int nx, int ny, int nz, ilImage *other, int ox,
  254.                                 int oy, int oz, int *chanList)
  255.  
  256.           ilStatus ilCopy(ilImage *img, ilImage *from)
  257.  
  258.  
  259.  
  260.  
  261.                                                                         PPPPaaaaggggeeee 4444
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  269.  
  270.  
  271.  
  272.           ilStatus ilGetTile3D(ilImage *img, int x, int y, int z, int nx,
  273.                                int ny, int nz, void *data, ilConfig *config)
  274.  
  275.           ilStatus ilImageQGetTile3D(ilImage *obj, ilMpNode* parent,
  276.                                      int x, int y, int z, int nx, int ny, int nz,
  277.                                      void** data, const ilConfig* config,
  278.                             ilMpManager** pMgr)
  279.  
  280.           ilStatus ilSetTile3D(ilImage *img, int x, int y, int z, int nx,
  281.                                int ny, int nz, const void *data, ilConfig *config)
  282.  
  283.           ilStatus ilImageQSetTile3D(ilImage *obj, ilMpNode* parent,
  284.                                      int x, int y, int z, int nx, int ny, int nz,
  285.                                      void* data, const ilConfig* config,
  286.                             ilMpManager** pMgr)
  287.  
  288.           ilStatus ilGetPixel3D(ilImage *img, int x, int y, int z,
  289.                                 iflPixel *pix)
  290.  
  291.           ilStatus ilSetPixel3D(ilImage *img, int x, int y, int z,
  292.                                 iflPixel *pix)
  293.  
  294.  
  295.      SSSSttttoooorrrriiiinnnngggg aaaannnndddd rrrreeeettttrrrriiiieeeevvvviiiinnnngggg 2222----DDDD iiiimmmmaaaaggggeeee ddddaaaattttaaaa
  296.  
  297.           ilStatus ilGetTile(ilImage *img, int x, int y, int nx, int ny,
  298.                              void *data, ilConfig *config)
  299.  
  300.           ilStatus ilSetTile(ilImage *img, int x, int y, int nx, int ny,
  301.                              const void *data, ilConfig *config)
  302.  
  303.           ilStatus ilGetSubTile(ilImage *img, int x, int y, int nx, int ny,
  304.                                 void *data, int dx, int dy, int dnx, int dny,
  305.                                 ilConfig *config)
  306.  
  307.           ilStatus ilSetSubTile(ilImage *img, int x, int y, int nx, int ny,
  308.                                 const void *data, int dx, int dy, int dnx, int dny,
  309.                                 ilConfig *config)
  310.  
  311.           ilStatus ilCopyTile(ilImage *img, int x, int y, int nx, int ny,
  312.                               ilImage *other, int ox, int oy, int *chanList)
  313.  
  314.           ilStatus ilFillTile(ilImage *img, int x, int y, int nx, int ny,
  315.                               void *data, ilConfig *config, iflTile2Dint *fillMask)
  316.  
  317.           ilStatus ilGetPixel(ilImage *img, int x, int y, iflPixel *pix)
  318.  
  319.           ilStatus ilSetPixel(ilImage *img, int x, int y, iflPixel *pix)
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.                                                                         PPPPaaaaggggeeee 5555
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  335.  
  336.  
  337.  
  338.      DDDDaaaattttaaaa aaaacccccccceeeessssssss ssssuuuuppppppppoooorrrrtttt
  339.  
  340.           ilStatus ilClipTile(ilImage *img, int *x, int *y, int *z, int *nx,
  341.                               int *ny, int *nz, int includeBorder)
  342.  
  343.           ilStatus ilClipTileAsTile(ilImage *obj, iflTile3Dint* t,
  344.                                     int includeBorder)
  345.           ilStatus ilClipTileFloat(ilImage *obj, float *x,
  346.                                          float *y, float *z,
  347.                                          float *nx, float *ny,
  348.                                          float *nz, int includeBorder)
  349.           ilStatus ilClipTileFloatAsTile(ilImage *obj, iflTile3Dfloat* t,
  350.                                                int includeBorder)
  351.           ilStatus ilConfigureRetainedCacheImage(ilImage *obj,
  352.                                                       const iflTile3Dint* tile,
  353.                                                       int c, int nc-1,
  354.                                                       int* chans,
  355.                                                       float minCacheBudget.05,
  356.                                                       float maxCacheBudget,
  357.                                                       size_t* retainedFileSize)
  358.           ilImageTile* ilGetInputTileRequirement(ilImage *obj,
  359.                                                       const iflTile3Dint* tile,
  360.                                                       int c, int nc,
  361.                                                       int* chans,
  362.                                                       int* pageSetCount)
  363.           void ilGetStrides(ilImage *obj, int* xs, int* ys, int* zs, int* cs,
  364.                                  int nx, int ny, int nz, int nc, iflOrder ord)
  365.  
  366.  
  367.      QQQQuuuueeeerrrryyyyiiiinnnngggg aaaabbbboooouuuutttt iiiimmmmaaaaggggeeee pppprrrrooooppppeeeerrrrttttiiiieeeessss
  368.  
  369.           void ilGetDimensions(ilImage* img, iflSize* size)
  370.           int ilGetXsize(ilImage *img)
  371.           int ilGetYsize(ilImage *img)
  372.           int ilGetZsize(ilImage *img)
  373.           int ilGetCsize(ilImage *img)
  374.           int  ilGetNumChans(ilImage *img)
  375.           int ilGetWidth(ilImage *img)
  376.           int ilGetHeight(ilImage *img)
  377.           void ilGetSize(ilImage *img, iflSize *sz)
  378.           iflSize* ilGetSizePtr(ilImage *img)
  379.           iflDataType ilGetDataType(ilImage *img)
  380.           iflOrder ilGetOrder(ilImage *img)
  381.           iflOrientation ilGetOrientation(ilImage *img)
  382.           void ilGetConfig(ilImage *img, ilConfig* cfg)
  383.           iflColorModel ilGetColorModel(ilImage *img)
  384.           iflCompression  ilGetCompression(ilImage *img)
  385.           void ilGetFill(ilImage *img, iflPixel *pixel)
  386.           double ilGetFillValue(ilImage *img, int c)
  387.           ilStatus ilGetColormap(ilImage *img, iflColormap *cmap)
  388.           iflColormap* ilGetColormapPtr(ilImage *img)
  389.           int ilGetMaxColormapLevels(ilImage *obj)
  390.  
  391.  
  392.  
  393.                                                                         PPPPaaaaggggeeee 6666
  394.  
  395.  
  396.  
  397.  
  398.  
  399.  
  400. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  401.  
  402.  
  403.  
  404.           int ilGetPageSizeBytes(ilImage *img)
  405.           size_t ilGetPageSizeXY(ilImage *img, int *nx, int *ny)
  406.           size_t ilGetPageSize(ilImage *img, int *nx, int *ny, int *nz, int *nc)
  407.           size_t ilGetPageSizeStruct(ilImage *img, iflSize *pageSize)
  408.           size_t ilGetMappedPageSize(ilImage *img, iflSize *pageSize, iflOrientation ori)
  409.           size_t ilGetPageDimensions(ilImage *img, iflSize *pageSize)
  410.           int ilGetPageSizeX(ilImage *img)
  411.           int ilGetPageSizeY(ilImage *img)
  412.           int ilGetPageSizeZ(ilImage *img)
  413.           int ilGetPageSizeC(ilImage *img)
  414.           int ilGetPageSizePix(ilImage *img)
  415.           int ilGetPageSizeVal(ilImage *img)
  416.           void ilGetPageDelta(ilImage *img, int *nx, int *ny, int *nz, int *nc)
  417.           void ilGetPageDeltaStruct(ilImage *img, iflXYZCint& delta)
  418.           void ilGetPageBorder(ilImage *img, iflXYZint *border)
  419.           iflXYZint* ilGetPageBorderPtr(ilImage *obj)
  420.           int ilGetPageBorderX()
  421.           int ilGetPageBorderY()
  422.           int ilGetPageBorderZ()
  423.           void ilGetPageCounts(ilImage *obj, int* nx, int* ny,
  424.                                     int* nz, int* nc)
  425.           void ilGetPageIndices(ilImage *obj, int x, int y,
  426.                                      int z, int c, int* ix, int* iy,
  427.                                      int* iz, int* ic)
  428.           ilStatus ilGetPageOrigin(int x, int y, int z, int c,
  429.                                    int *px, int *py, int *pz, int *pc)
  430.           ilStatus ilGetPageOriginStruct(const iflXYZCint *pos, iflXYZCint *org)
  431.           int ilGetPageOriginX(int x)
  432.           int ilGetPageOriginY(int y)
  433.           int ilGetPageOriginZ(int z)
  434.           int ilGetPageOriginC(int c)
  435.           int ilGetPriority(ilImage *img)
  436.           int ilHasPageBorder(ilImage *img)
  437.           int ilIsIntegral(ilImage *img)
  438.           int ilIsSigned(ilImage *img)
  439.           int ilIsWritable()
  440.  
  441.  
  442.      SSSSeeeettttttttiiiinnnngggg iiiimmmmaaaaggggeeee pppprrrrooooppppeeeerrrrttttiiiieeeessss
  443.  
  444.           ilStatus ilSetColorModel(ilImage *img, iflColorModel c)
  445.           ilStatus ilSetOrientation(ilImage *img, iflOrientation spc)
  446.           ilStatus ilSetDataType(ilImage *img, iflDataType dtype)
  447.           ilStatus ilSetCompression(ilImage *img, iflCompression c)
  448.           ilStatus ilSetFill(ilImage *img, iflPixel *pixel)
  449.           ilStatus ilSetFillValue(ilImage *img, double val, int c)
  450.           ilStatus ilSetFillRGB(ilImage *img, float red, float green, float blue)
  451.           ilStatus ilSetNumChans(ilImage *img, int nc)
  452.           ilStatus ilSetOrder(ilImage *img, iflOrder order)
  453.           void ilInitPageSize(ilImage *img, int x, int y, int z, int c)
  454.           ilStatus ilSetPageSize(ilImage *img, int nx, int ny, int nz, int nc)
  455.           ilStatus ilSetPageSizeStruct(ilImage *img, const iflSize *pageSize)
  456.  
  457.  
  458.  
  459.                                                                         PPPPaaaaggggeeee 7777
  460.  
  461.  
  462.  
  463.  
  464.  
  465.  
  466. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  467.  
  468.  
  469.  
  470.           ilStatus ilSetPageSizeXY(ilImage *img, int nx, int ny)
  471.           ilStatus ilSetPageSizeZ(int nz)
  472.           ilStatus ilSetPageSizeC(int nc)
  473.           ilStatus ilSetPageBorder(ilImage *img, int nx, int ny, int nz)
  474.           ilStatus ilSetPageBorderStruct(ilImage *img, const iflXYZint *border)
  475.           ilStatus ilSetSize(ilImage *img, iflSize *size)
  476.           ilStatus ilSetXYsize(ilImage *img, int nx, int ny)
  477.           ilStatus ilSetXsize(ilImage *img, int nx)
  478.           ilStatus ilSetYsize(ilImage *img, int ny)
  479.           ilStatus ilSetZsize(ilImage *img, int nz)
  480.           ilStatus ilSetCsize(ilImage *img, int nc)
  481.           ilStatus ilSetNumChans(ilImage *img, int nc)
  482.           ilStatus ilSetColormap(ilImage *img, iflColormap *cmap)
  483.           void ilSetMaxColormapLevels(ilImage* img, int maxLevels)
  484.           void ilSetPriority(ilImage *img, int pri)
  485.  
  486.  
  487.      QQQQuuuueeeerrrryyyyiiiinnnngggg aaaabbbboooouuuutttt mmmmiiiinnnniiiimmmmuuuummmm aaaannnndddd mmmmaaaaxxxxiiiimmmmuuuummmm ppppiiiixxxxeeeellll
  488.  
  489.           double ilGetMinValue(ilImage *img)
  490.           double ilGetMaxValue(ilImage *img)
  491.  
  492.  
  493.      SSSSeeeettttttttiiiinnnngggg mmmmiiiinnnniiiimmmmuuuummmm aaaannnndddd mmmmaaaaxxxxiiiimmmmuuuummmm ppppiiiixxxxeeeellll vvvvaaaalllluuuueeeessss
  494.  
  495.           ilStatus ilSetMinValue(ilImage *img, double val)
  496.           ilStatus ilSetMaxValue(ilImage *img, double val)
  497.  
  498.  
  499.      MMMMaaaannnnaaaaggggiiiinnnngggg tttthhhheeee IIIImmmmaaaaggggeeee''''ssss ssssttttaaaatttteeee
  500.  
  501.           ilLockedTile *ilLockTile3D(ilImage *img, int x, int y, int z,
  502.                          int nx, int ny, int nz,
  503.                               const ilConfig *config,  int mode)
  504.           ilLockedTile *ilLockTile(ilImage *img, int x, int y, int nx, int ny,
  505.                          const ilConfig *config, int mode)
  506.           ilStatus ilLockPageSet(ilImage *obj, ilLockRequest* set,
  507.                                  int mode, int count, ilCallback* perPageCb)
  508.           ilStatus ilQLockPageSet(ilImage *obj, ilMpNode* parent,
  509.                          ilLockRequest* set, int mode, int count,
  510.                          ilMpManager** pMgr, ilCallback* perPageCb)
  511.           void ilUnlockPageSet(ilImage *obj, ilLockRequest* set,
  512.                                int count)
  513.           ilPage* ilLockPage(ilImage *obj, int x, int y, int z, int c,
  514.                        ilStatus* status, int mode)
  515.           void ilUnlockPage(ilImage *obj, ilPage* page)
  516.           ilLockRequest* ilGetLockTileSet(ilImage *obj, int* count,
  517.                                           const iflTile3Dint* tile,
  518.                                           const ilConfig* config, int includeBorder)
  519.  
  520.           ilStatus ilLockedTileGetStatus(ilLockedTile *tile)
  521.           void ilLockedTileDelete(ilLockedTile *tile)
  522.  
  523.  
  524.  
  525.                                                                         PPPPaaaaggggeeee 8888
  526.  
  527.  
  528.  
  529.  
  530.  
  531.  
  532. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  533.  
  534.  
  535.  
  536.      OOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn ssssuuuuppppppppoooorrrrtttt
  537.  
  538.           void ilMapTile(ilImage *img, iflOrientation fromOri, iflTile2Dint *tile,
  539.                          iflOrientation workOri)
  540.           void ilMapTileFloat(ilImage *img, iflOrientation fromOri, iflTile2Dfloat *tile,
  541.                               iflOrientation workOri)
  542.           void ilMapTileFlipTrans(ilImage *img, iflOrientation fromOri, iflTile2Dint *tile,
  543.                                   iflFlip *flip, int *transXY, iflOrientation workOri)
  544.           void ilMapXY(ilImage *img, iflOrientation fromOri, int *x, int *y,
  545.                        iflOrientation workOri)
  546.           void ilMapXYFloat(ilImage *img, iflOrientation fromOri, float *x, float *y,
  547.                             iflOrientation workOri)
  548.           void ilMapXYSign(ilImage *img, iflOrientation fromOri, float *x, float *y,
  549.                        iflOrientation workOri)
  550.           void ilMapSize(ilImage *img, iflOrientation fromOri, int& x, int& y,
  551.                        iflOrientation workOri)
  552.           iflOrientation ilMapOrientation(ilImage *img, int flipX, int flipY, int transXY)
  553.           iflOrientation ilMapFlipTrans(ilImage *obj, iflOrientation fromOrientation,
  554.                                         iflFlip* flip, int* transXY,
  555.                                         iflOrientation workOrientation)
  556.           void ilGetMappedSize(ilImage *img, iflSize *size, iflOrientation workOri)
  557.           int ilIsMirrorOrientation(iflOrientation otherOri, iflOrientation workOri)
  558.  
  559.  
  560.      MMMMaaaappppppppiiiinnnngggg ttttoooo oooorrrr ffffrrrroooommmm ssssoooouuuurrrrcccceeee iiiimmmmaaaaggggeeee
  561.  
  562.           ilStatus ilMapToSource3D(ilImage *obj, float* x, float* y,
  563.               float* z, float u, float v, float w)
  564.           ilStatus ilMapToSource2D(ilImage *obj, float* x, float* y,
  565.               float u, float v)
  566.           ilStatus ilMapToSource(ilImage *obj, iflXYfloat* src,
  567.               const iflXYfloat* self)
  568.           ilStatus ilMapFromSource3D(ilImage *obj, float* u, float* v,
  569.               float* w, float x, float y, float z)
  570.           ilStatus ilMapFromSource2D(ilImage *obj, float* u, float* v,
  571.               float x, float y)
  572.           ilStatus ilMapFromSource(ilImage *obj, iflXYfloat* self,
  573.               const iflXYfloat* src)
  574.           virtual ilStatus ilMapToInput3D(ilImage *obj, float* x,
  575.               float* y, float* z, float u, float v, float w, int idx)
  576.           ilStatus ilMapToInput2D(ilImage *obj, float* x, float* y,
  577.               float u, float v, int idx)
  578.           ilStatus ilMapToInput(ilImage *obj, iflXYfloat* xy, const iflXYfloat* uv,
  579.               int idx)
  580.           ilStatus ilMapFromInput3D(ilImage *obj, float* u,
  581.               float* v, float* w, float x, float y, float z, int idx)
  582.           ilStatus ilMapFromInput2D(ilImage *obj, float* u, float* v,
  583.               float x, float y, int idx)
  584.           ilStatus ilMapFromInput(ilImage *obj, iflXYfloat* uv,
  585.               const iflXYfloat* xy, int idx)
  586.  
  587.      ilColorImg* ilGetColorImg(ilImage *obj, iflColorModel cm) int
  588.  
  589.  
  590.  
  591.                                                                         PPPPaaaaggggeeee 9999
  592.  
  593.  
  594.  
  595.  
  596.  
  597.  
  598. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  599.  
  600.  
  601.  
  602.      ilIsColorImg(ilImage *obj) double ilGetScaleMin(ilImage *img) double
  603.      ilGetScaleMax(ilImage *img) ilStatus ilSetScaleMinMax(ilImage *img,
  604.      double min, double max) ilStatus ilSetScaleType(ilImage *img, iflDataType
  605.      type) void ilInitScaleMinMax(ilImage *img, int force)
  606.  
  607.  
  608.      HHHHaaaarrrrddddwwwwaaaarrrreeee AAAAcccccccceeeelllleeeerrrraaaattttiiiioooonnnn
  609.  
  610.           void ilSetHwEnable(ilImage *obj, ilHwAccelEnable enable)
  611.           ilHwAccelEnable ilHwGetEnableImage(ilImage *obj)
  612.           int ilGetDisplayCacheEnable(ilImage *obj)
  613.  
  614.  
  615.      MMMMiiiisssscccceeeellllllllaaaannnneeeeoooouuuussss
  616.  
  617.           void *ilAllocFillData(ilImage *img, float red, float green, float blue)
  618.           void ilFreeFillData(ilImage *img, void *data)
  619.  
  620.  
  621. FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNNSSSS
  622.      iiiillllIIIImmmmaaaaggggeeeeDDDDeeeelllleeeetttteeee
  623.  
  624.           void ilImageDelete(ilImage *img)
  625.  
  626.      Deletes the ilImage pointed to by _i_m_g.
  627.  
  628.      aaaallllllllooooccccFFFFiiiillllllllDDDDaaaattttaaaa(((())))
  629.  
  630.           void* ilAllocFillData(ilImage *obj, float red, float green,
  631.                                 float blue)
  632.  
  633.  
  634.           This function allocates a pixel and sets it to correspond to the
  635.           given _r_e_d, _g_r_e_e_n, and _b_l_u_e pixel components.  The returned value
  636.           points to the allocated pixel, which should be free'd with
  637.           ffffrrrreeeeeeeeFFFFiiiillllllllDDDDaaaattttaaaa().
  638.  
  639.      aaaaddddddddIIIInnnnppppuuuutttt(((())))
  640.  
  641.           ilStatus ilAddInput(ilImage *img, ilImage *inimg)
  642.  
  643.  
  644.           Adds the image pointed to by _i_n_i_m_g to the end of the input (parent)
  645.           list.  See sssseeeettttIIIInnnnppppuuuutttt().
  646.  
  647.      cccclllliiiippppTTTTiiiilllleeee(((())))
  648.  
  649.           ilStatus ilClipTile(ilImage *img, int *x, int *y, int *z, int *nx,
  650.                               int *ny, int *nz, int includeBorder)
  651.           ilStatus ilClipTileAsTile(ilImage *obj, iflTile3Dint* t,
  652.                                     int includeBorder)
  653.           ilStatus ilClipTileFloat(ilImage *obj, float *x,
  654.  
  655.  
  656.  
  657.                                                                        PPPPaaaaggggeeee 11110000
  658.  
  659.  
  660.  
  661.  
  662.  
  663.  
  664. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  665.  
  666.  
  667.  
  668.                                    float *y, float *z,
  669.                                    float *nx, float *ny,
  670.                                    float *nz, int includeBorder)
  671.           ilStatus ilClipTileFloatAsTile(ilImage *obj, iflTile3Dfloat* t,
  672.                                    int includeBorder)
  673.  
  674.  
  675.           Clips the given tile parameters to the image bounds.  The tile
  676.           boundaries might be passed as parameters to iiiillllGGGGeeeettttTTTTiiiilllleeee3333DDDD() or
  677.           iiiillllSSSSeeeettttTTTTiiiilllleeee3333DDDD(), for example.  The tile may be specified as six int
  678.           parameters, or as an iflTile3Dint.  Alternative versions allow the
  679.           parameters to be passed as float.  If _i_n_c_l_u_d_e_B_o_r_d_e_r is TRUE, then
  680.           the clip bounds are increased to include the size of the page
  681.           border, if any (see sssseeeettttPPPPaaaaggggeeeeBBBBoooorrrrddddeeeerrrr(((())))).  If any of the parameters
  682.           needed to be clipped to fit the image, this function returns
  683.           ilDATACLIPPED; otherwise, it returns ilOKAY.
  684.  
  685.      ccccoooonnnnffffiiiigggguuuurrrreeeeRRRReeeettttaaaaiiiinnnneeeeddddCCCCaaaacccchhhheeee(((())))
  686.  
  687.           ilStatus ilConfigureRetainedCacheImage(ilImage *obj,
  688.                                                       const iflTile3Dint* tile,
  689.                                                       int c, int nc-1,
  690.                                                       int* chans,
  691.                                                       float minCacheBudget.05,
  692.                                                       float maxCacheBudget,
  693.                                                       size_t* retainedFileSize)
  694.  
  695.  
  696.           Convenience method that calls iiiillllCCCCoooonnnnffffiiiigggguuuurrrreeeeRRRReeeettttaaaaiiiinnnneeeeddddCCCCaaaacccchhhheeee() with a
  697.           single iiiillllIIIImmmmaaaaggggeeeeTTTTiiiilllleeee that specifies the tile for this image denoted in
  698.           the arguments _t_i_l_e, _c, _n_c, and _c_h_a_n_s.  The remaining arguments are
  699.           passed directly to iiiillllCCCCoooonnnnffffiiiigggguuuurrrreeeeRRRReeeettttaaaaiiiinnnneeeeddddCCCCaaaacccchhhheeee().  The value returned
  700.           by iiiillllCCCCoooonnnnffffiiiigggguuuurrrreeeeRRRReeeettttaaaaiiiinnnneeeeddddCCCCaaaacccchhhheeee() is returned.
  701.  
  702.      ccccooooppppyyyy(((())))
  703.  
  704.           ilStatus ilCopy(ilImage* to, ilImage* from)
  705.  
  706.  
  707.           Copies data from the image specified by _f_r_o_m.  If the two images are
  708.           of different sizes, only the origin-aligned  intersecting portion is
  709.           copied.  See also ccccooooppppyyyyTTTTiiiilllleeee3333DDDD().
  710.  
  711.      ccccooooppppyyyyTTTTiiiilllleeee(((())))
  712.  
  713.           ilStatus ilCopyTile(ilImage *img, int x, int y, int nx, int ny,
  714.                               ilImage *other, int ox, int oy, int *chanList)
  715.           ilStatus ilCopyTile3D(ilImage *img, int x, int y, int z,
  716.                                 int nx, int ny, int nz, ilImage *other, int ox,
  717.                                 int oy, int oz, int *chanList)
  718.           ilStatus ilCopyTileCfg(ilImage *img, int x, int y, int z,
  719.                                 int nx, int ny, int nz, ilImage *other, int ox,
  720.  
  721.  
  722.  
  723.                                                                        PPPPaaaaggggeeee 11111111
  724.  
  725.  
  726.  
  727.  
  728.  
  729.  
  730. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  731.  
  732.  
  733.  
  734.                                 int oy, int oz, ilConfig *config)
  735.  
  736.  
  737.           These functions queue a copyTile request with iiiillllQQQQCCCCooooppppyyyyTTTTiiiilllleeeeCCCCffffgggg() and
  738.           wait for it to complete.  The tile at _x, _y, _z of size _n_x, _n_y, _n_z is
  739.           copied to this image from _o_t_h_e_r image at _o_x, _o_y, _o_z.  The 2D
  740.           version, iiiillllCCCCooooppppyyyyTTTTiiiilllleeee() calls the corresponding 3D routine with _z set
  741.           to zero and _n_z and _o_z set to one.
  742.  
  743.           iiiillllCCCCooooppppyyyyTTTTiiiilllleeeeCCCCffffgggg() takes an ilConfig argument, _c_o_n_f_i_g, which is used to
  744.           reconfigure the pixel data type, order, channels and orientation as
  745.           well as offsetting into the channel dimension.  The other two copy
  746.           routines accept a channel list, which is used to construct an
  747.           ilConfig object with all other taken from "this" image.  The channel
  748.           list in _c_o_n_f_i_g specifies a channel mapping between the "other" and
  749.           "this" image. The number of entries in the list should always match
  750.           the number of channels in "this" image. A -1  means no data is
  751.           written for that channel.
  752.  
  753.           See also iiiillllQQQQCCCCooooppppyyyyTTTTiiiilllleeeeCCCCffffgggg() and iiiillllGGGGeeeettttCCCCoooonnnnffffiiiigggg().
  754.  
  755.      ffffiiiillllllllTTTTiiiilllleeee(((())))
  756.  
  757.           ilStatus ilFillTile(ilImage *img, int x, int y, int nx, int ny,
  758.                         const void *data, ilConfig *config, iflTile2Dint *fillMask)
  759.           ilStatus ilFillTile3D(ilImage *img, int x, int y, int z,
  760.                           int nx, int ny, int nz, const void *data,
  761.                           ilConfig *config, iflTile2Dint *fillMask)
  762.           ilStatus ilFillTileRGB(int x, int y, int z, int nx, int ny, int nz,
  763.                            float red, float green, float blue,
  764.                            const iflTile3Dint* fillMask=NULL,
  765.                            iflOrientation orientation);
  766.  
  767.  
  768.           These functions queue a fill tile request with iiiillllQQQQFFFFiiiillllllllTTTTiiiilllleeee3333DDDD() or
  769.           iiiillllQQQQFFFFiiiillllllllTTTTiiiilllleeeeRRRRGGGGBBBB() and wait for it to complete.  The tile at position
  770.           (_x,_y,_z) of size _n_x, _n_y, _n_z will be filled with a constant pixel
  771.           value.  iiiillllFFFFiiiillllllllTTTTiiiilllleeee() sets _z to zero and _n_z to one.
  772.  
  773.           _c_o_n_f_i_g describes the configuration (See the ilConfig man page) of
  774.           the fill value _d_a_t_a; if NULL, it is assumed to have the same
  775.           configuration as the image.  For example, to fill a tile of an RGB
  776.           image with white, _d_a_t_a should hold the values (255, 255, 255).
  777.           iiiillllFFFFiiiillllllllTTTTiiiilllleeeeRRRRGGGGBBBB() is provided as a convenience method for RGB images;
  778.           the _r_e_d, _g_r_e_e_n, and _b_l_u_e pixel components are passed directly as
  779.           floats.
  780.  
  781.           The parameter, _f_i_l_l_M_a_s_k, can be used to prevent filling a portion of
  782.           the tile.  If _f_i_l_l_M_a_s_k is not NULL, only the portion outside of
  783.           _f_i_l_l_M_a_s_k is filled. If _c_o_n_f_i_g is not NULL and it specifies a valid
  784.           orientation, then _f_i_l_l_M_a_s_k is mapped from that orientation to that
  785.           of the image; otherwise _f_i_l_l_M_a_s_k is assumed to have the same
  786.  
  787.  
  788.  
  789.                                                                        PPPPaaaaggggeeee 11112222
  790.  
  791.  
  792.  
  793.  
  794.  
  795.  
  796. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  797.  
  798.  
  799.  
  800.           orientation as that of the image.  iiiillllFFFFiiiillllllllTTTTiiiilllleeeeRRRRGGGGBBBB() takes a mask
  801.           _o_r_i_e_n_t_a_t_i_o_n as a parameter; a value of zero will default to the
  802.           orientation of the image.
  803.  
  804.           See also the ilCacheImg man page.
  805.  
  806.      ffffrrrreeeeeeeeFFFFiiiillllllllDDDDaaaattttaaaa(((())))
  807.  
  808.           void ilFreeFillData(ilImage *obj, void* data)
  809.  
  810.  
  811.           This function free's a pixel allocated with aaaallllllllooooccccFFFFiiiillllllllDDDDaaaattttaaaa().
  812.  
  813.      ggggeeeettttDDDDiiiimmmmeeeennnnssssiiiioooonnnnssss(((())))
  814.  
  815.           void ilGetDimensions(iflSize *size)
  816.  
  817.  
  818.           Returns the size of the image in the ilLowerLeftOrigin orientation.
  819.  
  820.      ggggeeeettttDDDDiiiirrrreeeeccccttttIIIInnnnppppuuuutttt(((())))
  821.  
  822.           ilImage* ilGetDirectInput(ilImage *obj, int idx)
  823.  
  824.  
  825.           Return the direct input at index _i_d_x, ignoring whether or not it is
  826.           enabled.  (See ggggeeeettttIIIInnnnppppuuuutttt() and iiiillllLLLLiiiinnnnkkkk::::::::ggggeeeettttDDDDiiiirrrreeeeccccttttPPPPaaaarrrreeeennnntttt().)
  827.  
  828.      ggggeeeettttDDDDiiiissssppppllllaaaayyyyCCCCaaaacccchhhheeeeEEEEnnnnaaaabbbblllleeee(((())))
  829.  
  830.           int ilGetDisplayCacheEnable(ilImage *obj)
  831.  
  832.  
  833.           Returns the current setting for the display cache enable. See
  834.           sssseeeettttDDDDiiiissssppppllllaaaayyyyCCCCaaaacccchhhheeeeEEEEnnnnaaaabbbblllleeee.
  835.  
  836.      ggggeeeettttCCCCoooolllloooorrrrIIIImmmmgggg(((())))
  837.  
  838.           ilColorImg* getColorImg(iflColorModel cm)
  839.  
  840.  
  841.           Returns a pointer to an ilColorImg that is a child of "this" image
  842.           and has the color model specified by _c_m. The new color converter
  843.           inherits most attributes, except for the color model and the number
  844.           of channels, from "this" image.
  845.  
  846.  
  847.  
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854.  
  855.                                                                        PPPPaaaaggggeeee 11113333
  856.  
  857.  
  858.  
  859.  
  860.  
  861.  
  862. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  863.  
  864.  
  865.  
  866.      ggggeeeettttCCCCoooolllloooorrrrmmmmaaaapppp(((())))
  867.  
  868.           ilStatus ilGetColormap(ilImage *img, iflColormap *cmap)
  869.           iflColormap* ilGetColormapPtr(ilImage *img)
  870.  
  871.  
  872.           These functions return the image's colormap.  The first version
  873.           deposits the image's color map in the iflColormap object pointed to
  874.           by _c_m_a_p and returns a status value.  The status value is either the
  875.           image's status or ilNULLOBJ, if the colormap is NULL.  If ilOKAY is
  876.           not returned, then the argument is unchanged.  The second version
  877.           returns a pointer to this image object's colormap, which may be
  878.           NULL.
  879.  
  880.      ggggeeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll(((())))
  881.  
  882.           iflColorModel ilGetColorModel(ilImage *img)
  883.  
  884.  
  885.           Returns the color model of the image. _i_f_l_C_o_l_o_r_M_o_d_e_l is an enumerated
  886.           type with the following members:
  888.           _i_f_l_R_G_B         red, green, blue
  889.  
  890.           _i_f_l_R_G_B_A        red, green, blue, alpha
  891.  
  892.           _i_f_l_R_G_B_P_a_l_e_t_t_e  RGB color mapped to a look-up  table
  893.  
  894.           _i_f_l_H_S_V         hue, saturation, value
  895.  
  896.           _i_f_l_C_M_Y         cyan, magenta, yellow
  897.  
  898.           _i_f_l_C_M_Y_K        cyan, magenta, yellow, black
  899.  
  900.           _i_f_l_N_e_g_a_t_i_v_e    inverted luminance (min is white, max is black)
  901.  
  902.           _i_f_l_L_u_m_i_n_a_n_c_e   luminance
  903.  
  904.           _i_f_l_L_u_m_i_n_a_n_c_e_A_l_p_h_a
  905.                          luminance, alpha
  906.  
  907.           _i_f_l_B_G_R         swapped RGB, for images generated by SGI
  908.  
  909.           _i_f_l_A_B_G_R        swapped RGBA, for images generated by SGI
  910.  
  911.           _i_f_l_M_u_l_t_i_S_p_e_c_t_r_a_l
  912.                          multiple channels of sensor-specific  data
  914.           The color model is used to interpret the meaning of the channels
  915.           that make up a pixel. See also iiiillllSSSSeeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll().
  916.  
  917.  
  918.  
  919.  
  920.                                                                        PPPPaaaaggggeeee 11114444
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  928.  
  929.  
  930.  
  931.      ggggeeeettttCCCCoooommmmpppprrrreeeessssssssiiiioooonnnn(((())))
  932.  
  933.           iflCompression ilGetCompression(ilImage *img)
  934.  
  935.  
  936.           Returns the image compression parameter as the enumerated type,
  937.           _i_f_l_C_o_m_p_r_e_s_s_i_o_n.  This parameter reflects the type of compression
  938.           used in the image data.  See also iiiillllSSSSeeeettttCCCCoooommmmpppprrrreeeessssssssiiiioooonnnn().
  939.  
  940.      ggggeeeettttCCCCoooonnnnffffiiiigggg(((())))
  941.  
  942.           void ilGetConfig(ilImage *img, ilConfig* cfg)
  943.  
  944.  
  945.           Returns the image's configuration in the ilConfig object pointed to
  946.           by _c_f_g. The ilConfig class (see _i_l/_i_l_C_o_n_f_i_g._h) contains eight
  947.           elements:  an iflDataType that defines the data type of the image's
  948.           pixels, an iflOrder that describes how that data is ordered, an int
  949.           that sets how many data channels there are, an array of ints that
  950.           determines the order of the channels, an iflOrientation, and three
  951.           zoom factors for the three dimensions.  See also iiiillllGGGGeeeettttDDDDaaaattttaaaaTTTTyyyyppppeeee(),
  952.           iiiillllGGGGeeeettttOOOOrrrrddddeeeerrrr(), iiiillllGGGGeeeettttNNNNuuuummmmCCCChhhhaaaannnnssss(), and iiiillllGGGGeeeettttOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn().
  953.  
  954.      ggggeeeettttOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn(((())))
  955.  
  956.           iflOrientation ilGetOrientation(ilImage *img)
  957.  
  958.  
  959.           Returns the image orientation parameter as the enumerated type,
  960.           _i_f_l_O_r_i_e_n_t_a_t_i_o_n. This parameter determines, for example, whether the
  961.           image origin is the upper left corner or the lower left corner.  See
  962.           also iiiillllSSSSeeeettttOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn().
  963.  
  964.      ggggeeeettttCCCCssssiiiizzzzeeee(((())))
  965.  
  966.           int ilGetCsize(ilImage *img)
  967.           int ilGetNumChans(ilImage *img)
  968.  
  969.  
  970.           Returns the number of channels in the image. For example an RGB
  971.           image is a 3 channel image.
  972.  
  973.      ggggeeeettttDDDDaaaattttaaaaTTTTyyyyppppeeee(((())))
  974.  
  975.           iflDataType ilGetDataType(ilImage *img)
  976.  
  977.  
  978.           Returns the data type of the image's pixels.  The iflDataType value
  979.           returned can be one of the following: _i_f_l_B_i_t, _i_f_l_C_h_a_r, _i_f_l_U_C_h_a_r,
  980.           _i_f_l_S_h_o_r_t, _i_f_l_U_S_h_o_r_t, _i_f_l_L_o_n_g, _i_f_l_U_L_o_n_g, _i_f_l_F_l_o_a_t, or _i_f_l_D_o_u_b_l_e.  See
  981.           also iiiillllGGGGeeeettttCCCCoooonnnnffffiiiigggg().
  982.  
  983.  
  984.  
  985.  
  986.                                                                        PPPPaaaaggggeeee 11115555
  987.  
  988.  
  989.  
  990.  
  991.  
  992.  
  993. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  994.  
  995.  
  996.  
  997.      ggggeeeettttFFFFiiiillllllll(((())))
  998.  
  999.           iflPixel *pixel ilGetFill(ilImage *img)
  1000.  
  1001.  
  1002.           Returns a reference to the image's fill pixel value. See also
  1003.           iiiillllSSSSeeeettttFFFFiiiillllllll().
  1004.  
  1005.      ggggeeeettttFFFFiiiillllllllDDDDaaaattttaaaa(((())))
  1006.  
  1007.           void* ilGetFillData(ilImage *img)
  1008.  
  1009.  
  1010.           This function calls the ggggeeeettttDDDDaaaattttaaaa() method of the image's fill pixel
  1011.           and returns the result.
  1012.  
  1013.      ggggeeeettttFFFFiiiillllllllVVVVaaaalllluuuueeee(((())))
  1014.  
  1015.           double ilGetFillValue(ilImage *img, int c)
  1016.  
  1017.  
  1018.           Returns the image fill value of channel _c.  See also iiiillllGGGGeeeettttFFFFiiiillllllll().
  1019.  
  1020.      ggggeeeettttHHHHeeeeiiiigggghhhhtttt(((())))
  1021.  
  1022.           int getHeight(ilImage *img)
  1023.  
  1024.  
  1025.           Returns the height of _i_m_g.  See also ilGetWidth() and ilGetYsize().
  1026.  
  1027.      ggggeeeettttHHHHwwwwEEEEnnnnaaaabbbblllleeee(((())))
  1028.  
  1029.           ilHwAccelEnable ilGetHwEnable(ilImage *obj)
  1030.  
  1031.  
  1032.           This function returns the value of the hardware acceleration enable
  1033.           flag as set by sssseeeettttHHHHwwwwEEEEnnnnaaaabbbblllleeee().
  1034.  
  1035.      ggggeeeettttIIIInnnnppppuuuutttt(((())))
  1036.  
  1037.           ilImage *ilGetInput(ilImage *img, int idx)
  1038.  
  1039.  
  1040.           Returns a pointer to the ilImage at index _i_d_x in the parent list.
  1041.           NULL is returned if there is no image at the specified index.
  1042.  
  1043.      ggggeeeettttIIIInnnnppppuuuuttttTTTTiiiilllleeeeRRRReeeeqqqquuuuiiiirrrreeeemmmmeeeennnntttt(((())))
  1044.  
  1045.           ilImageTile* ilGetInputTileRequirement(ilImage *obj,
  1046.                                                       const iflTile3Dint* tile,
  1047.                                                       int c, int nc,
  1048.                                                       int* chans,
  1049.  
  1050.  
  1051.  
  1052.                                                                        PPPPaaaaggggeeee 11116666
  1053.  
  1054.  
  1055.  
  1056.  
  1057.  
  1058.  
  1059. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1060.  
  1061.  
  1062.  
  1063.                                                       int* pageSetCount)
  1064.  
  1065.  
  1066.           This method is used by the global function
  1067.           iiiillllCCCCoooonnnnffffiiiigggguuuurrrreeeeRRRReeeettttaaaaiiiinnnneeeeddddCCCCaaaacccchhhheeee() to determine the input data requirement
  1068.           to evaluate a given output tile.  The method really ought to be a
  1069.           virtual, so that derived classes can easily override its behavior,
  1070.           but it cannot be done this way and still maintain binary
  1071.           compatibility with IL 3.1.1.  Therefore, a derived class can
  1072.           override the behavior of this method only by calling the method
  1073.           sssseeeettttTTTTiiiilllleeeeRRRReeeeqqqquuuuiiiirrrreeeemmmmeeeennnnttttFFFFuuuunnnnccccttttiiiioooonnnn() to establish a new behavior.
  1074.  
  1075.           The default implementation returns an array of iiiillllIIIImmmmaaaaggggeeeeTTTTiiiilllleeee's, one
  1076.           for each of the image's inputs, with tile coordinates identical to
  1077.           the passed tile coordinates.  Derived classes, such as iiiillllMMMMoooonnnnaaaaddddiiiiccccIIIImmmmgggg
  1078.           and iiiillllPPPPoooollllyyyyaaaaddddiiiiccccIIIImmmmgggg, override the default behavior to take input
  1079.           offsets into account.  iiiillllWWWWaaaarrrrppppIIIImmmmgggg overrides the default behavior to
  1080.           incorporate the effect of the warp.  As an example of overriding the
  1081.           default behavior, here is iiiillllPPPPoooollllyyyyaaaaddddiiiiccccIIIImmmmgggg's version:
  1082.  
  1083.           ilImageTile*
  1084.           ilPolyadicImg::getInputTileRequirement(const iflTile& tile, int c, int nc,
  1085.                                      int* chans, int& inputTileCount)
  1086.           {
  1087.               if (resetCheck()) { inputTileCount = 0; return NULL; }
  1088.  
  1089.               int count = getNumParents();
  1090.               ilImageTile* inputTiles = new ilImageTile [count];
  1091.  
  1092.               int activeCount = 0;
  1093.               ilLinkParentIter iter(this);
  1094.               ilLink* link;
  1095.               while (link = iter.next()) {
  1096.                if (link->derivesFrom(iflClassID(ilImage))) {
  1097.                    ilImage* img = (ilImage*)link;
  1098.                    iflTile offTile = tile;
  1099.                    int idx = iter.currIndex();
  1100.                    if (idx >= 0) {
  1101.                     int x, y, z;
  1102.                     getOffset(x, y, z, idx);
  1103.                     offTile.x -= x;
  1104.                     offTile.y -= y;
  1105.                     offTile.z -= z;
  1106.                    }
  1107.                    inputTiles[activeCount++].init(img, offTile, c, nc, chans);
  1108.                }
  1109.                else if (link->derivesFrom(iflClassID(ilImgStat)))
  1110.                    activeCount += ((ilImgStat*)link)
  1111.                             ->getInputTileRequirement(inputTiles[activeCount]);
  1112.               }
  1113.  
  1114.               inputTileCount = activeCount;
  1115.  
  1116.  
  1117.  
  1118.                                                                        PPPPaaaaggggeeee 11117777
  1119.  
  1120.  
  1121.  
  1122.  
  1123.  
  1124.  
  1125. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1126.  
  1127.  
  1128.  
  1129.               if (activeCount == 0) { delete inputTiles; inputTiles = NULL; }
  1130.  
  1131.               return inputTiles;
  1132.           }
  1133.  
  1134.  
  1135.      ggggeeeettttLLLLoooocccckkkkTTTTiiiilllleeeeSSSSeeeetttt(((())))
  1136.  
  1137.           ilLockRequest* ilImageGetLockTileSet(ilImage *obj, int* count,
  1138.                                                const iflTile3Dint* tile,
  1139.                                                const ilConfig* config,
  1140.                                                int includeBorder)
  1141.  
  1142.  
  1143.           This function generates an array of ilLockRequests corresponding to
  1144.           the specified "tile" in the image.  These requests can then be
  1145.           passed to iiiillllLLLLoooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt() and iiiillllUUUUnnnnlllloooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt() to lock the pages
  1146.           comprising the tile.  If _i_n_c_l_u_d_e_B_o_r_d_e_r is TRUE then all pages that
  1147.           intersect the tile comprise the set.  Otherwise, the smallest set of
  1148.           pages that cover the tile comprises the set.  This distinction is
  1149.           relevant only if the image has non-zero page borders.  Generally,
  1150.           you should set _i_n_c_l_u_d_e_B_o_r_d_e_r to TRUE if you are generating the set
  1151.           for writing, and FALSE if you are generating the set for reading.
  1152.           The number of generated lock requests is returned in the reference
  1153.           parameter "count".  The returned ilLockRequest set is in nnnneeeewwww()'ed
  1154.           memory.  It is the responsibility of the caller to delete the set
  1155.           when no longer in use.
  1156.  
  1157.      ggggeeeettttMMMMaaaaxxxxCCCCoooolllloooorrrrmmmmaaaappppLLLLeeeevvvveeeellllssss(((())))
  1158.  
  1159.           int ilImageGetMaxColormapLevels(ilImage *obj)
  1160.  
  1161.  
  1162.           This function returns the maximum color map level attribute set with
  1163.           iiiillllSSSSeeeettttMMMMaaaaxxxxCCCCoooolllloooorrrrmmmmaaaappppLLLLeeeevvvveeeellllssss().
  1164.  
  1165.      ggggeeeettttMMMMaaaaxxxxVVVVaaaalllluuuueeee(((())))
  1166.  
  1167.           double ilGetMaxValue(ilImage *img)
  1168.  
  1169.  
  1170.           Returns the maximum allowable value for this image object.
  1171.  
  1172.      ggggeeeettttMMMMiiiinnnnVVVVaaaalllluuuueeee(((())))
  1173.  
  1174.           double ilGetMinValue(ilImage *img)
  1175.  
  1176.  
  1177.           Returns the minimum allowable value for this image object.
  1178.  
  1179.  
  1180.  
  1181.  
  1182.  
  1183.  
  1184.                                                                        PPPPaaaaggggeeee 11118888
  1185.  
  1186.  
  1187.  
  1188.  
  1189.  
  1190.  
  1191. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1192.  
  1193.  
  1194.  
  1195.      ggggeeeettttNNNNuuuummmmIIIInnnnppppuuuuttttssss(((())))
  1196.  
  1197.           int ilGetNumInputs(ilImage *img)
  1198.  
  1199.  
  1200.           Returns the number of images in this image's input (parent) list.
  1201.  
  1202.      ggggeeeettttOOOOrrrrddddeeeerrrr(((())))
  1203.  
  1204.           iflOrder ilGetOrder(ilImage *img)
  1205.  
  1206.  
  1207.           Returns the pixel channel order of this image. The enumerated type,
  1208.           _i_f_l_O_r_d_e_r, has members _i_f_l_I_n_t_e_r_l_e_a_v_e_d, _i_f_l_S_e_q_u_e_n_t_i_a_l, or _i_f_l_S_e_p_a_r_a_t_e
  1209.           to indicate how the pixel data is ordered.
  1210.  
  1211.           For _i_f_l_I_n_t_e_r_l_e_a_v_e_d, all pixel channels are stored adjacently.  For
  1212.           an RGB color image, this would be RGBRGBRGB, and so forth.  For
  1213.           _i_f_l_S_e_q_u_e_n_t_i_a_l, each pixel channel is stored as a separate line.  For
  1214.           an RGB color image, this is a line of Red, followed by a line of
  1215.           Green, followed by a line of Blue for one line of RGB pixels.  For
  1216.           _i_f_l_S_e_p_a_r_a_t_e, each channel is stored in a separate page.  See the
  1217.           _I_m_a_g_e_V_i_s_i_o_n _L_i_b_r_a_r_y _P_r_o_g_r_a_m_m_i_n_g _G_u_i_d_e for more details.
  1218.  
  1219.      ggggeeeettttPPPPaaaaggggeeeeBBBBoooorrrrddddeeeerrrr(((())))
  1220.  
  1221.           void ilGetPageBorder(ilImage *img, iflXYZint *border)
  1222.           const iflXYZint& ilGetPageBorderPtr(ilImage *obj)
  1223.           int ilGetPageBorderX()
  1224.           int ilGetPageBorderY()
  1225.           int ilGetPageBorderZ()
  1226.  
  1227.  
  1228.           Returns the page border size in an iflXYZint structure.
  1229.  
  1230.           The alternative methods provide access to the per-coordinate page
  1231.           border values.
  1232.  
  1233.      ggggeeeettttPPPPaaaaggggeeeeCCCCoooouuuunnnnttttssss(((())))
  1234.  
  1235.           void ilGetPageCounts(ilImage *obj, int* nx, int* ny,
  1236.                                     int* nz, int* nc)
  1237.  
  1238.  
  1239.           Returns the number of pages required to cover the entire image
  1240.           extent in each of the _x, _y, _z, and _c dimensions
  1241.  
  1242.      ggggeeeettttPPPPaaaaggggeeeeDDDDeeeellllttttaaaa(((())))
  1243.  
  1244.           void ilGetPageDelta(ilImage *img, int *nx, int *ny, int *nz, int *nc)
  1245.           void ilGetPageDeltaStruct(ilImage *img, int *nx, int *ny, int *nz, int *nc)
  1246.  
  1247.  
  1248.  
  1249.  
  1250.                                                                        PPPPaaaaggggeeee 11119999
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1258.  
  1259.  
  1260.  
  1261.           Returns the effective page size with page borders removed.  It is
  1262.           computed by subtracting twice the page border size from the current
  1263.           page size.
  1264.  
  1265.      ggggeeeettttPPPPaaaaggggeeeeIIIInnnnddddiiiicccceeeessss(((())))
  1266.  
  1267.           void ilGetPageIndices(ilImage *obj, int x, int y,
  1268.                                      int z, int c, int* ix, int* iy,
  1269.                                      int* iz, int* ic)
  1270.  
  1271.  
  1272.           Return the indices of the image page containing the point (_x, _y, _z,
  1273.           _c).
  1274.  
  1275.      ggggeeeettttPPPPaaaaggggeeeeOOOOrrrriiiiggggiiiinnnn(((())))
  1276.  
  1277.           ilStatus ilGetPageOrigin(int x, int y, int z, int c,
  1278.                                    int *px, int *py, int *pz, int *pc)
  1279.           ilStatus ilGetPageOriginStruct(const iflXYZCint *pos, iflXYZCint *org)
  1280.           int ilGetPageOriginX(int x)
  1281.           int ilGetPageOriginY(int y)
  1282.           int ilGetPageOriginZ(int z)
  1283.           int ilGetPageOriginC(int c)
  1284.  
  1285.  
  1286.           This method returns the origin of the page that contains the point
  1287.           passed in as _x, _y, _z, and _c.  The coordinates of the page are
  1288.           returned in _p_x, _p_y, _p_c, and _p_z.  The returned page coordinates may
  1289.           correspond to a page that does not actually reside within the image
  1290.           bounds if the passed pixel coordinates are also outside the image
  1291.           bounds.  If the image has page borders, then it is possible that
  1292.           more than one page contains the point.  In this case, the page with
  1293.           the greatest coordinate values is returned.
  1294.  
  1295.           If the image's status is not ilOKAY, then that status is returned
  1296.           and the page coordinates values are not set.  Otherwise, ilOKAY is
  1297.           returned.
  1298.  
  1299.           Alternative methods are provided to compute each of the page
  1300.           coordinates independently.
  1301.  
  1302.      ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeee(((())))
  1303.  
  1304.           size_t ilGetPageSizeBytes(ilImage *img)
  1305.           size_t ilGetPageSizeXY(ilImage *img, int *hx, int *ny)
  1306.           size_t ilGetPageSize(ilImage *img, int *nx, int *ny, int *nz, int *nc)
  1307.           size_t ilGetPageSizeStruct(ilImage *img, iflSize *pageSize)
  1308.           size_t ilGetMappedPageSize(ilImage *img, iflSize *pageSize, iflOrientation ori)
  1309.           size_t ilGetPageDimensions(ilImage *img, iflSize *pageSize)
  1310.  
  1311.  
  1312.  
  1313.  
  1314.  
  1315.  
  1316.                                                                        PPPPaaaaggggeeee 22220000
  1317.  
  1318.  
  1319.  
  1320.  
  1321.  
  1322.  
  1323. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1324.  
  1325.  
  1326.  
  1327.           Returns the image page size in bytes. This takes into account the
  1328.           number of channels per pixel and the channel data type.  The second
  1329.           and third versions also return the page size in the x, y, z, c
  1330.           dimensions in _n_x, _n_y, _n_z and _n_c.  The fourth version returns the
  1331.           page size in an iflSize structure, possibly transformed into the
  1332.           orientation specified in _o_r_i. The x and y page size will be
  1333.           transposed as needed, based on the orientation. See also the
  1334.           ilCacheImg man page.
  1335.  
  1336.           The iiiillllGGGGeeeettttPPPPaaaaggggeeeeDDDDiiiimmmmeeeennnnssssiiiioooonnnnssss function returns the page size in a standard
  1337.           (non-transposed) orientation.  This is useful if you are interested
  1338.           in the "width" or "height" of a page, independent of the data
  1339.           orientation.
  1340.  
  1341.      ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeeeXXXX(((()))) ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeeeYYYY(((()))) ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeeeZZZZ(((()))) ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeeeCCCC(((())))
  1342.  
  1343.           int ilGetPageSizeX(ilImage *img)
  1344.           int ilGetPageSizeY(ilImage *img)
  1345.           int ilGetPageSizeZ(ilImage *img)
  1346.           int ilGetPageSizeC(ilImage *img)
  1347.  
  1348.  
  1349.           Returns the image's page size in the _x-, _y-, _z-, _c-dimensions,
  1350.           respectively.
  1351.  
  1352.      ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeeePPPPiiiixxxx(((())))
  1353.  
  1354.           int ilGetPageSizePix(ilImage *img)
  1355.  
  1356.  
  1357.           Returns the image page size in pixels.  See also iiiillllGGGGeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeee().
  1358.  
  1359.      ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeeeVVVVaaaallll(((())))
  1360.  
  1361.           int ilGetPageSizeVal(ilImage *img)
  1362.  
  1363.  
  1364.           Returns the image page size in terms of discrete values. This takes
  1365.           into account the number of channels per pixel that is, it returns
  1366.           ggggeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeeePPPPiiiixxxx() * number of channels in the page).  See also
  1367.           iiiillllGGGGeeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeee().
  1368.  
  1369.      ggggeeeettttPPPPiiiixxxxeeeellll(((())))
  1370.  
  1371.           ilStatus ilGetPixel(ilImage *img, int x, int y, iflPixel *pix)
  1372.  
  1373.  
  1374.           This function is the 2-D version of iiiillllGGGGeeeettttPPPPiiiixxxxeeeellll3333DDDD().  It calls
  1375.           iiiillllGGGGeeeettttPPPPiiiixxxxeeeellll3333DDDD() with _z set to 0.  See also ggggeeeettttPPPPiiiixxxxeeeellll3333DDDD().
  1376.  
  1377.  
  1378.  
  1379.  
  1380.  
  1381.  
  1382.                                                                        PPPPaaaaggggeeee 22221111
  1383.  
  1384.  
  1385.  
  1386.  
  1387.  
  1388.  
  1389. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1390.  
  1391.  
  1392.  
  1393.      ggggeeeettttPPPPiiiixxxxeeeellll3333DDDD(((())))
  1394.  
  1395.           ilStatus ilGetPixel3D(ilImage *img, int x, int y, int z,
  1396.                                 iflPixel *pix)
  1397.  
  1398.  
  1399.           Gets the iflPixel at the point specified by _x, _y, and _z and returns
  1400.           it in _p_i_x.  An iflPixel specifies the channel data type, the number
  1401.           of channels per pixel and a pointer to the pixel data.  This
  1402.           function calls iiiillllGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() with the tile size _n_x, _n_y, _n_z set to
  1403.           1. Returns ilOKAY upon successful completion.  See also
  1404.           iiiillllGGGGeeeettttPPPPiiiixxxxeeeellll(), iiiillllGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() and iiiillllSSSSeeeettttPPPPiiiixxxxeeeellll3333DDDD().
  1405.  
  1406.      ggggeeeettttPPPPrrrriiiioooorrrriiiittttyyyy(((())))
  1407.  
  1408.           int ilGetPriority(ilImage *img)
  1409.  
  1410.  
  1411.           This function gets the current cache priority of this image.  See
  1412.           sssseeeettttPPPPrrrriiiioooorrrriiiittttyyyy() for more details.
  1413.  
  1414.      ggggeeeettttSSSSccccaaaalllleeeeMMMMaaaaxxxx(((())))
  1415.  
  1416.           double ilGetScaleMax(ilImage *img)
  1417.  
  1418.  
  1419.           Returns the maximum value used for scaling during color conversion
  1420.           and display.  By default the maximum scale value tracks the maximum
  1421.           value of the image. However, it may be set with sssseeeettttSSSSccccaaaalllleeeeMMMMiiiinnnnMMMMaaaaxxxx().
  1422.  
  1423.      ggggeeeettttSSSSccccaaaalllleeeeMMMMiiiinnnn(((())))
  1424.  
  1425.           double ilGetScaleMin(ilImage *img)
  1426.  
  1427.  
  1428.           Returns the minimum value used for scaling during color conversion
  1429.           and display.  By default the minimum scale value tracks the minimum
  1430.           value of the image. However, it may be set with sssseeeettttSSSSccccaaaalllleeeeMMMMiiiinnnnMMMMaaaaxxxx().
  1431.  
  1432.      ggggeeeettttSSSSiiiizzzzeeee(((())))
  1433.  
  1434.           void ilGetSize(ilImage *img, iflSize *size)
  1435.           void ilGetMappedSize(ilImage *img, iflSize *size, iflOrientation workOri)
  1436.           iflSize* ilGetSizePtr(ilImage *img)
  1437.  
  1438.  
  1439.           The first version returns the image size in the iflSize object
  1440.           referenced by _s_i_z_e.  An iflSize has integer member variables _x, _y,
  1441.           _z, and _c to hold each dimension of the image.  The second version
  1442.           first maps the image's size to the orientation indicated by _w_o_r_k_O_r_i.
  1443.           If the indicated orientation is transposed relative to the image's
  1444.           orientation, then the _x and _y sizes are swapped in the returned
  1445.  
  1446.  
  1447.  
  1448.                                                                        PPPPaaaaggggeeee 22222222
  1449.  
  1450.  
  1451.  
  1452.  
  1453.  
  1454.  
  1455. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1456.  
  1457.  
  1458.  
  1459.           size.  See also iiiillllGGGGeeeettttXXXXSSSSiiiizzzzeeee(), iiiillllGGGGeeeettttYYYYSSSSiiiizzzzeeee(), iiiillllGGGGeeeettttZZZZSSSSiiiizzzzeeee() and
  1460.           iiiillllGGGGeeeettttCCCCSSSSiiiizzzzeeee().  The third version returns a reference to the actual
  1461.           _s_i_z_e attribute of this image object.
  1462.  
  1463.      ggggeeeettttSSSSttttrrrriiiiddddeeeessss(((())))
  1464.  
  1465.           void ilGetStrides(ilImage *obj, int* xs, int* ys, int* zs, int* cs,
  1466.                                  int nx, int ny, int nz, int nc, iflOrder ord)
  1467.  
  1468.  
  1469.           Returns by reference the x stride (_x_s), y stride (_y_s), z stride
  1470.           (_z_s), channel stride (_c_s) and number of channels (_n_c). The buffer
  1471.           strides are used to step through a data buffer of size _n_x by _n_y that
  1472.           contains pixels with channel order _o_r_d.  If the order is
  1473.           _n_u_m_i_f_l_O_r_d_e_r_s it causes the current data order to be used.
  1474.  
  1475.           The x stride is used to step from one pixel to the next in the same
  1476.           row. The y stride is used to step to the next pixel in the same
  1477.           column. For 3D images, the z stride is used to step to the next
  1478.           pixel along the z axis at the same xy location. A multiplier _n can
  1479.           be used to move _n pixels in a desired direction within the data
  1480.           buffer.
  1481.  
  1482.           The channel stride is used to step to the next channel of the same
  1483.           pixel.
  1484.  
  1485.      ggggeeeettttTTTTiiiilllleeee(((())))
  1486.  
  1487.           ilStatus ilGetTile(ilImage *img, int x, int y, int nx, int ny,
  1488.                              void *data, ilConfig *config)
  1489.           ilStatus ilGetTile3D(ilImage *img, int x, int y, int z,
  1490.                          int nx, int ny, int nz, void *data,
  1491.                          ilConfig *config)
  1492.           ilStatus ilGetSubTile(ilImage *img, int x, int y, int nx, int ny,
  1493.                                 void *data, int dx, int dy, int dnx, int dny,
  1494.                           ilConfig *config)
  1495.           ilStatus ilGetSubTile3D(ilImage *img, int x, int y, int z,
  1496.                          int nx, int ny, int nz, void *data,
  1497.                          int dx, int dy, int dz,
  1498.                          int dnx, int dny, int dnz, ilConfig *config)
  1499.  
  1500.  
  1501.           These functions queue a tile read request with iiiillllQQQQGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() and
  1502.           wait for it to complete.  The source tile origin is specified by _x,
  1503.           _y, _z, and the tile size is specified by _n_x, _n_y, _n_z.
  1504.  
  1505.           The 2D versions, iiiillllGGGGeeeettttTTTTiiiilllleeee() and iiiillllGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee(), call the
  1506.           corresponding 3D routine with _z set to zero and _n_z set to one.
  1507.  
  1508.           iiiillllGGGGeeeettttTTTTiiiilllleeee() and iiiillllGGGGeeeettttTTTTiiiilllleeee3333DDDD() assume that the destination buffer has
  1509.           the same offset and size as the request; iiiillllGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee() and
  1510.           iiiillllGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() allow the destination buffer to have a different
  1511.  
  1512.  
  1513.  
  1514.                                                                        PPPPaaaaggggeeee 22223333
  1515.  
  1516.  
  1517.  
  1518.  
  1519.  
  1520.  
  1521. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1522.  
  1523.  
  1524.  
  1525.           position and size, specified by _d_x, _d_y, _d_n_x, and _d_n_y (and _d_z and _d_n_z
  1526.           for the 3D version.)
  1527.  
  1528.           Optionally, an ilConfig object pointed to by _c_o_n_f_i_g can be used to
  1529.           specify the desired data type, order, number of channels and channel
  1530.           order. _c_o_n_f_i_g is NULL by default, meaning that no conversion is
  1531.           performed on the input data.
  1532.  
  1533.           See also iiiillllQQQQGGGGeeeettttTTTTiiiilllleeee3333DDDD(), iiiillllQQQQGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() and iiiillllGGGGeeeettttCCCCoooonnnnffffiiiigggg().
  1534.  
  1535.      ggggeeeettttWWWWiiiiddddtttthhhh(((())))
  1536.  
  1537.           int getWidth(ilImage *img)
  1538.  
  1539.  
  1540.           Returns the width of _i_m_g.  See also ilGetHeight() and ilGetXsize().
  1541.  
  1542.      ggggeeeettttXXXXssssiiiizzzzeeee(((())))
  1543.  
  1544.           int ilGetXsize(ilImage *img)
  1545.  
  1546.  
  1547.           Returns the size of the image in the _x-dimension, measured in
  1548.           pixels.
  1549.  
  1550.           Note that by definition in the IL, the _x-dimension is always the
  1551.           fastest varying dimension in image memory order.  I.e. the scanline
  1552.           dimension.  In non-transposed orientations, scanlines are oriented
  1553.           horizontally with respect to the image.  Thus, for non-transposed
  1554.           orientations ilGetXsize() returns the _w_i_d_t_h of the image.  In
  1555.           transposed orientations the scanlines are oriented vertically with
  1556.           respect to the image and ilGetXsize() returns the _h_e_i_g_h_t of the
  1557.           image.  Transposed orientations are: _i_f_l_L_e_f_t_U_p_p_e_r_O_r_i_g_i_n,
  1558.           _i_f_l_R_i_g_h_t_U_p_p_e_r_O_r_i_g_i_n, _i_f_l_R_i_g_h_t_L_o_w_e_r_O_r_i_g_i_n and _i_f_l_L_e_f_t_L_o_w_e_r_O_r_i_g_i_n.
  1559.           See also iiiillllGGGGeeeettttHHHHeeeeiiiigggghhhhtttt(), iiiillllGGGGeeeettttWWWWiiiiddddtttthhhh(), iiiillllGGGGeeeettttSSSSiiiizzzzeeee(), iiiillllGGGGeeeettttYYYYssssiiiizzzzeeee() and
  1560.           iiiillllGGGGeeeettttZZZZssssiiiizzzzeeee().
  1561.  
  1562.      ggggeeeettttYYYYssssiiiizzzzeeee(((())))
  1563.  
  1564.           int ilGetYsize(ilImage *img)
  1565.  
  1566.  
  1567.           Returns the size of the image in the _y-dimension, measured in
  1568.           pixels.  See also iiiillllGGGGeeeettttHHHHeeeeiiiigggghhhhtttt(), iiiillllGGGGeeeettttWWWWiiiiddddtttthhhh(), iiiillllGGGGeeeettttSSSSiiiizzzzeeee(),
  1569.           iiiillllGGGGeeeettttXXXXssssiiiizzzzeeee() and iiiillllGGGGeeeettttZZZZssssiiiizzzzeeee().
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576.  
  1577.  
  1578.  
  1579.  
  1580.                                                                        PPPPaaaaggggeeee 22224444
  1581.  
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1588.  
  1589.  
  1590.  
  1591.      ggggeeeettttZZZZssssiiiizzzzeeee(((())))
  1592.  
  1593.           int ilGetZsize(ilImage *img)
  1594.  
  1595.  
  1596.           Returns the size of the image in the _z-dimension. This value can be
  1597.           thought of as representing the number of _x_y planes in an image.  For
  1598.           two-dimensional images, the returned value is 1.  Refer to the
  1599.           _I_m_a_g_e_V_i_s_i_o_n _L_i_b_r_a_r_y _P_r_o_g_r_a_m_m_i_n_g _G_u_i_d_e for more details.  See also
  1600.           iiiillllGGGGeeeettttSSSSiiiizzzzeeee(), iiiillllGGGGeeeettttXXXXssssiiiizzzzeeee() and iiiillllGGGGeeeettttYYYYssssiiiizzzzeeee().
  1601.  
  1602.      hhhhaaaassssPPPPaaaaggggeeeeBBBBoooorrrrddddeeeerrrr(((())))
  1603.  
  1604.           int ilHasPageBorder(ilImage *img)
  1605.  
  1606.  
  1607.           This functions returns TRUE if the image has page borders, FALSE
  1608.           otherwise.  iiiinnnniiiittttCCCCoooolllloooorrrrMMMMooooddddeeeellll(((())))
  1609.  
  1610.           void initColorModel(int noAlpha=FALSE)                        _p_r_o_t_e_c_t_e_d
  1611.  
  1612.  
  1613.           Initializes the color model based on the number of channels if it
  1614.           has never been explicitly set with sssseeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll().  Images with one
  1615.           channel are set to _i_f_l_L_u_m_i_n_a_n_c_e.  Images with two channel are set to
  1616.           _i_f_l_L_u_m_i_n_a_n_c_e_A_l_p_h_a.  Images with three channels are set to _i_f_l_R_G_B.
  1617.           Images with four channels are set to _i_f_l_R_G_B_A by default.  If _n_o_A_l_p_h_a
  1618.           is true, then images with two or four channels are set to
  1619.           _i_f_l_M_u_l_t_i_S_p_e_c_t_r_a_l instead.  All other cases are set to
  1620.           _i_f_l_M_u_l_t_i_S_p_e_c_t_r_a_l.
  1621.  
  1622.      iiiinnnniiiittttSSSSccccaaaalllleeeeMMMMiiiinnnnMMMMaaaaxxxx(((())))
  1623.  
  1624.           void ilInitScaleMinMax(ilImage *img, int force)
  1625.  
  1626.  
  1627.           Initializes the scale minimum and maximum to the image minimum and
  1628.           maximum values. If scale minimum and maximum have already been set,
  1629.           they are unchanged, unless _f_o_r_c_e is TRUE. The scale minimum and
  1630.           maximum are used during color conversion and display.  By default,
  1631.           the scale minimum and maximum track the image minimum and maximum
  1632.           values.
  1633.  
  1634.      iiiissssCCCCoooolllloooorrrrIIIImmmmgggg(((())))
  1635.  
  1636.           int ilIsColorImg()
  1637.  
  1638.  
  1639.           Returns TRUE if the image is a color converter that was created with
  1640.           ggggeeeettttCCCCoooolllloooorrrrIIIImmmmgggg().  Otherwise FALSE is returned.
  1641.  
  1642.  
  1643.  
  1644.  
  1645.  
  1646.                                                                        PPPPaaaaggggeeee 22225555
  1647.  
  1648.  
  1649.  
  1650.  
  1651.  
  1652.  
  1653. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1654.  
  1655.  
  1656.  
  1657.      iiiissssIIIInnnntttteeeeggggrrrraaaallll(((())))
  1658.  
  1659.           int ilIsIntegral(ilImage *img)
  1660.  
  1661.  
  1662.           Returns TRUE if the image's data type is an integral valued type. If
  1663.           it is a floating point type, then FALSE is returned. This function
  1664.           is based on the standalone function, iiiiffffllllDDDDaaaattttaaaaIIIIssssIIIInnnntttteeeeggggrrrraaaallll() (see the
  1665.           iflDataSize man page).
  1666.  
  1667.      iiiissssMMMMiiiirrrrrrrroooorrrrOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn(((())))
  1668.  
  1669.           int ilIsMirrorOrientation(iflOrientation otherOri, iflOrientation workOri)
  1670.  
  1671.  
  1672.           The routine returns _T_R_U_E if _o_t_h_e_r_O_r_i is a mirror image of _w_o_r_k_O_r_i.
  1673.           If _w_o_r_k_O_r_i is 0, the orientation of the image is used instead.  This
  1674.           can be useful when implementing operations that have calculations
  1675.           that depend on a particular frame of reference.  For example, when
  1676.           implementing an image rotation operator, the angle can need to be
  1677.           negated to produce consistent results on inputs of arbitrary
  1678.           orientation.
  1679.  
  1680.      iiiissssSSSSiiiiggggnnnneeeedddd(((())))
  1681.  
  1682.           int ilIsSigned(ilImage *img)
  1683.  
  1684.  
  1685.           Returns TRUE if the image's data type is signed. If it is unsigned,
  1686.           then FALSE is returned. This function is based on the standalone
  1687.           function, iiiiffffllllDDDDaaaattttaaaaIIIIssssSSSSiiiiggggnnnneeeedddd() (see the iflDataSize man page).
  1688.  
  1689.      iiiissssWWWWrrrriiiittttaaaabbbblllleeee(((())))
  1690.  
  1691.           int ilImageIsWritable(ilImage *obj)
  1692.  
  1693.  
  1694.           This function returns TRUE if the image can be written to; FALSE
  1695.           otherwise.
  1696.  
  1697.      lllloooocccckkkkPPPPaaaaggggeeee(((())))
  1698.  
  1699.           ilPage* ilImageLockPage(ilImage *obj, int x, int y, int z,
  1700.                                   int c, ilStatus* status, int mode)
  1701.  
  1702.  
  1703.           This is the single page version of ilLockPageSet(). It returns a
  1704.           pointer to the page containing the pixel _x, _y, _z, _c.  The _s_t_a_t_u_s
  1705.           value specifies the error code if a page could
  1706.            not be referenced.  If the function succeeds, _s_t_a_t_u_s is set to
  1707.           ilOKAY. See ilQLockPageSet() for a description of _m_o_d_e and possible
  1708.           _s_t_a_t_u_s returns. See also _i_l_U_n_l_o_c_k_P_a_g_e().
  1709.  
  1710.  
  1711.  
  1712.                                                                        PPPPaaaaggggeeee 22226666
  1713.  
  1714.  
  1715.  
  1716.  
  1717.  
  1718.  
  1719. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1720.  
  1721.  
  1722.  
  1723.      lllloooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt(((())))
  1724.  
  1725.           ilStatus ilImageLockPageSet(ilImage *obj, ilLockRequest* set,
  1726.                                       int mode, int count, ilCallback* perPageCb)
  1727.  
  1728.  
  1729.           This function queues a list of lock page requests with
  1730.           iiiillllQQQQLLLLoooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt() and waits for them to complete.  Each ilLockRequest
  1731.           in the _s_e_t array is locked and a pointer to the page is deposited in
  1732.           the corresponding ilLockRequest.  As a consequence, this causes all
  1733.           the image data for the pages to be computed.  If all of the requests
  1734.           succeed, ilOKAY is returned.  If one or more fail, an error code
  1735.           will be returned and the ilLockRequest structures will contain
  1736.           individual status codes.  At a later time, iiiillllUUUUnnnnlllloooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt() can be
  1737.           called to release the set of pages.
  1738.  
  1739.           See iiiillllQQQQLLLLoooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt() and iiiillllUUUUnnnnlllloooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt() for more information.
  1740.  
  1741.      lllloooocccckkkkTTTTiiiilllleeee(((())))
  1742.  
  1743.           ilLockedTile *lockTile(int x, int y, int nx, int ny,
  1744.                          const ilConfig* config, int mode)
  1745.  
  1746.  
  1747.           This is the 2-D version of ilLockTile3D().  It calls ilLockTile3D()
  1748.           with _z set to 0 and _n_z set to 1.  See also ilLockedTileDelete().
  1749.  
  1750.      lllloooocccckkkkTTTTiiiilllleeee3333DDDD(((())))
  1751.  
  1752.           ilLockedTile *lockTile3D(int x, int y, int z, int nx, int ny, int nz,
  1753.                          const ilConfig* config, int mode)
  1754.  
  1755.  
  1756.           This function causes the tiles that intersect the indicated image
  1757.           volume to be ``locked.''  This is accomplished by ``locking'' the
  1758.           image pages which store the data for the affected tiles.  These
  1759.           pages remain locked until the ilLockedTile object returned by
  1760.           ilLockTile3D() is deleted.  The status result of the function can be
  1761.           retrieved by calling ilLockedTileGetStatus() with the returned
  1762.           ilLockedTile object.
  1763.  
  1764.      mmmmaaaappppFFFFlllliiiippppTTTTrrrraaaannnnssss(((())))
  1765.  
  1766.           iflOrientation ilImageMapFlipTrans(ilImage *obj, iflOrientation fromOrientation,
  1767.                                              iflFlip* flip, int* transXY,
  1768.                                              iflOrientation workOrientation)
  1769.  
  1770.  
  1771.           This function determines the flips and/or transpositions required to
  1772.           map from _f_r_o_m_O_r_i_e_n_t_a_t_i_o_n to _w_o_r_k_O_r_i_e_n_t_a_t_i_o_n (if the work orientation
  1773.           is zero, the image's orientation is used).  The return value is the
  1774.           work orientation.  The required _f_l_i_p and _t_r_a_n_s_X_Y values are also
  1775.  
  1776.  
  1777.  
  1778.                                                                        PPPPaaaaggggeeee 22227777
  1779.  
  1780.  
  1781.  
  1782.  
  1783.  
  1784.  
  1785. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1786.  
  1787.  
  1788.  
  1789.           returned.
  1790.  
  1791.      mmmmaaaappppFFFFrrrroooommmmIIIInnnnppppuuuutttt(((())))
  1792.  
  1793.           ilStatus ilMapFromInput3D(ilImage *obj, float* u,
  1794.               float* v, float* w, float x, float y, float z, int idx)
  1795.           ilStatus ilMapFromInput2D(ilImage *obj, float* u, float* v,
  1796.               float x, float y, int idx)
  1797.           ilStatus ilMapFromInput(ilImage *obj, iflXYfloat* uv,
  1798.               const iflXYfloat* xy, int idx)
  1799.  
  1800.  
  1801.           Maps a point, (_x,_y,_z), from the _i_d_x'th input image's output
  1802.           coordinate space to this image's output coordinate space and returns
  1803.           the result in (_u,_v,_w).  This virtual function's default
  1804.           implementation is the identity mapping.  It can be overridden in
  1805.           derived classes (like ilWarpImg) to take into account any address
  1806.           manipulations that an operator can perform.  The overloaded versions
  1807.           provide 2D address mapping, which is sufficient for most
  1808.           applications.  Note that the IL does not yet support images with
  1809.           non-identity coordinate mappings in the z dimension, and all
  1810.           coordinates (input and output) are described in the orientation of
  1811.           this image. See also mmmmaaaappppFFFFrrrroooommmmSSSSoooouuuurrrrcccceeee(((()))), mmmmaaaappppTTTTooooIIIInnnnppppuuuutttt(((()))).
  1812.  
  1813.      mmmmaaaappppFFFFrrrroooommmmSSSSoooouuuurrrrcccceeee(((())))
  1814.  
  1815.           ilStatus ilMapFromSource3D(ilImage *obj, float* u, float* v, float* w,
  1816.               float x, float y, float z)
  1817.           ilStatus ilMapFromSource2D(ilImage *obj, float* u, float* v,
  1818.               float x, float y)
  1819.           ilStatus ilMapFromSource(ilImage *obj, iflXYfloat* self,
  1820.               const iflXYfloat* src)
  1821.  
  1822.  
  1823.           Maps a point, (_x,_y,_z), in the ultimate source image's input
  1824.           coordinate space to this image's output coordinate space and returns
  1825.           the result in (_u,_v,_w).  Both points are defined in this image's
  1826.           orientation. One possible use for this is to determine where to plot
  1827.           annotation that is tied to the source image when zooming and
  1828.           rotating an image.  The ilView function, sssseeeettttLLLLoooocccc(((()))), also uses this
  1829.           function to position a location in the source image of an operator
  1830.           chain at the center of the viewed region.  The overloaded versions
  1831.           provide 2D address mapping, which is sufficient for most
  1832.           applications.  Note that the IL does not yet support images with
  1833.           non-identity coordinate mappings in the z dimension.  See also
  1834.           mmmmaaaappppTTTTooooSSSSoooouuuurrrrcccceeee(((()))), mmmmaaaappppFFFFrrrroooommmmIIIInnnnppppuuuutttt(((()))) and the ilView man page.
  1835.  
  1836.  
  1837.  
  1838.  
  1839.  
  1840.  
  1841.  
  1842.  
  1843.  
  1844.                                                                        PPPPaaaaggggeeee 22228888
  1845.  
  1846.  
  1847.  
  1848.  
  1849.  
  1850.  
  1851. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1852.  
  1853.  
  1854.  
  1855.      mmmmaaaappppSSSSiiiizzzzeeee(((())))
  1856.  
  1857.           void mapSize(ilImage* img, iflOrientation fromOri, int& x, int& y, iflOrientation workOri)
  1858.  
  1859.  
  1860.           Transposes the _x and _y size as needed, based on _f_r_o_m_O_r_i and _w_o_r_k_O_r_i.
  1861.           If _w_o_r_k_O_r_i is 0, then the image's orientation is used.
  1862.  
  1863.      mmmmaaaappppOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn(((())))
  1864.  
  1865.           iflOrientation ilMapOrientation(ilImage *img, int flipX, int flipY, int transXY)
  1866.  
  1867.  
  1868.           The function returns the orientation that results from applying the
  1869.           flips and transpose requested to the image's orientation.  If _f_l_i_p_X
  1870.           is TRUE, the _x dimension is flipped.  If _f_l_i_p_Y is TRUE, the _y
  1871.           dimension is flipped.  If _t_r_a_n_s_X_Y is TRUE, the _x and _y dimensions
  1872.           are transposed.
  1873.  
  1874.      mmmmaaaappppTTTTiiiilllleeee(((())))
  1875.  
  1876.           void ilMapTile(ilImage *img, iflOrientation fromOri, iflTile2Dint *tile,
  1877.                          iflOrientation workOri)
  1878.           void ilMapTileFloat(ilImage *img, iflOrientation fromOri, iflTile2Dfloat *tile,
  1879.                               iflOrientation workOri)
  1880.           void ilMapTileFlipTrans(ilImage *img, iflOrientation fromOri, iflTile2Dint *tile,
  1881.                                   iflFlip *flip, int *transXY, iflOrientation workOri)
  1882.  
  1883.  
  1884.           The tile referenced by _t_i_l_e is mapped from orientation _f_r_o_m_O_r_i to
  1885.           the orientation _w_o_r_k_O_r_i.  If _w_o_r_k_O_r_i is 0, the orientation of the
  1886.           image is used instead.  The origin and size members of _t_i_l_e are
  1887.           recomputed to reflect this mapping.  The value returned in the
  1888.           iflFlip enumerated type, _f_l_i_p indicates whether the _x or the _y axis,
  1889.           or both, had to be flipped to effect the mapping.
  1890.  
  1891.           If no flipping was required, then _i_f_l_N_o_F_l_i_p is returned.  If the _x
  1892.           or _y axis was flipped, _i_f_l_X_F_l_i_p or _i_f_l_Y_F_l_i_p is returned.  If both
  1893.           axes were flipped, (_i_f_l_X_F_l_i_p | _i_f_l_Y_F_l_i_p) is returned. If, to effect
  1894.           the mapping, the x and y axes had to be interchanged (that is, the
  1895.           new x origin and size are the old y origin and size and the converse
  1896.           is true), then a 1 is returned in _t_r_a_n_s_X_Y; otherwise _t_r_a_n_s_X_Y is 0.
  1897.  
  1898.      mmmmaaaappppTTTTooooIIIInnnnppppuuuutttt(((())))
  1899.  
  1900.           ilStatus ilMapToInput3D(ilImage *obj, float* x,
  1901.               float* y, float* z, float u, float v, float w, int idx)
  1902.           ilStatus ilMapToInput2D(ilImage *obj, float* x, float* y,
  1903.               float u, float v, int idx)
  1904.           ilStatus ilMapToInput(ilImage *obj, iflXYfloat* xy,
  1905.               const iflXYfloat* uv, int idx)
  1906.  
  1907.  
  1908.  
  1909.  
  1910.                                                                        PPPPaaaaggggeeee 22229999
  1911.  
  1912.  
  1913.  
  1914.  
  1915.  
  1916.  
  1917. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1918.  
  1919.  
  1920.  
  1921.           Maps a point, (_u,_v,_w), in this image's output coordinate space to
  1922.           the _i_d_x'th input image's output coordinate space and returns the
  1923.           result in (_x,_y,_z).  This virtual function's default implementation
  1924.           assumes the identity mapping.  It can be overridden in derived
  1925.           classes (like ilWarpImg) to take into account any address
  1926.           manipulations that an operator can perform.  The overloaded versions
  1927.           provide 2D address mapping, which is sufficient for most
  1928.           applications.  Note that the IL does not yet support images with
  1929.           non-identity coordinate mappings in the z dimension, and all points
  1930.           are defined in the orientation of this image. See also
  1931.           mmmmaaaappppTTTTooooSSSSoooouuuurrrrcccceeee(((()))), mmmmaaaappppFFFFrrrroooommmmIIIInnnnppppuuuutttt(((()))).
  1932.  
  1933.      mmmmaaaappppTTTTooooSSSSoooouuuurrrrcccceeee(((())))
  1934.  
  1935.           ilStatus ilMapToSource3D(ilImage *obj, float* x, float* y,
  1936.               float* z, float u, float v, float w)
  1937.           ilStatus ilMapToSource2D(ilImage *obj, float* x, float* y,
  1938.               float u, float v)
  1939.           ilStatus ilMapToSource(ilImage *obj, iflXYfloat* src,
  1940.               const iflXYfloat* self)
  1941.  
  1942.  
  1943.           Maps a point, (_u,_v,_w), in this image's output coordinate space to
  1944.           the ultimate source image's input coordinate space and returns the
  1945.           result in (_x,_y,_z).  All coordinates are defined in this image's
  1946.           orientation.  One possible use for this is to find the source image
  1947.           coordinates of a screen location in a zoomed and rotated image.  The
  1948.           ilView function, ggggeeeettttLLLLoooocccc(((()))), uses this function to accomplish this
  1949.           task.  The overloaded versions provide 2D address mapping, which is
  1950.           sufficient for most applications.  Note that the IL does not yet
  1951.           support images with non-identity coordinate mappings in the z
  1952.           dimension.  See also mmmmaaaappppFFFFrrrroooommmmSSSSoooouuuurrrrcccceeee(((()))), mmmmaaaappppTTTTooooIIIInnnnppppuuuutttt(((()))) and the ilView
  1953.           man page.
  1954.  
  1955.      mmmmaaaappppXXXXYYYY(((())))
  1956.  
  1957.           void ilMapXY(ilImage *img, iflOrientation fromOri, int *x, int *y,
  1958.                        iflOrientation workOri)
  1959.           void ilMapXYFloat(ilImage *img, iflOrientation fromOri, float *x, float *y,
  1960.                             iflOrientation workOri)
  1961.           void ilMapXYSign(ilImage *img, iflOrientation fromOri, float *x, float *y,
  1962.                        iflOrientation workOri)
  1963.  
  1964.  
  1965.           The (x,y) pair of values referenced by _x and _y is mapped from
  1966.           orientation _f_r_o_m_O_r_i to the orientation _w_o_r_k_O_r_i.  If _w_o_r_k_O_r_i is 0,
  1967.           the orientation of the image is used instead.  In the _i_l_M_a_p_X_Y_S_i_g_n
  1968.           function, if a flip in the _x or _y dimensions is required to
  1969.           transform between the two orienations, the _x and _y values are
  1970.           negated accordingly.  If a transpose is required, the _x and _y values
  1971.           are swapped.
  1972.  
  1973.  
  1974.  
  1975.  
  1976.                                                                        PPPPaaaaggggeeee 33330000
  1977.  
  1978.  
  1979.  
  1980.  
  1981.  
  1982.  
  1983. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  1984.  
  1985.  
  1986.  
  1987.      qqqqCCCCooooppppyyyyTTTTiiiilllleeeeCCCCffffgggg(((())))
  1988.  
  1989.           ilStatus ilQCopyTileCfg(ilMpNode* parent, int x, int y, int z,
  1990.                             int nx, int ny, int nz, ilImage* other,
  1991.                             int ox, int oy, int oz,
  1992.                             const ilConfig* config=NULL, ilMpManager** pMgr=NULL)
  1993.  
  1994.  
  1995.           This virtual function should be defined by derived classes to queue
  1996.           a request to copy a tile from the _o_t_h_e_r image to this image object.
  1997.           The tile is copied to location _x, _y, _z in this image; the tile size
  1998.           is specified by _n_x, _n_y, _n_z.  The source tile is at location _o_x, _o_y,
  1999.           _o_z in the _o_t_h_e_r image.  The _c_o_n_f_i_g parameter may be used to specify
  2000.           a channel list and/or offset (the other fields are ignored).
  2001.  
  2002.           If the _o_t_h_e_r image has a different data type or order than this
  2003.           image, then the data is converted as it is copied.  If the two
  2004.           image's color models are different, a color converter is chained
  2005.           onto the _o_t_h_e_r image UNLESS a channel list or offset is specified
  2006.           with _c_o_n_f_i_g; the channel re-ordering will be presumed to resolve any
  2007.           color model difference.
  2008.  
  2009.           The _p_a_r_e_n_t MP node (if not NULL) will have this operation added as a
  2010.           dependent node.  The MP manager for this queued operation will be
  2011.           returned via the _p_M_g_r parameter (if not NULL) and can then used to
  2012.           wait for completion, obtain a status code, and/or abort.  For more
  2013.           information on MP synchronization, see the ilMpManager man page.
  2014.  
  2015.      qqqqFFFFiiiillllllllTTTTiiiilllleeee3333DDDD(((())))
  2016.  
  2017.           ilStatus ilQFillTile3D(ilMpNode* parent, int x, int y, int z,
  2018.                            int nx, int ny, int nz, const void* data,
  2019.                            const ilConfig* config, const iflTile3Dint* fillMask,
  2020.                            ilMpManager** pMgr);
  2021.  
  2022.  
  2023.           This virtual function should be defined by derived classes to queue
  2024.           a request to fill a tile at location _x, _y, _z of size _n_x, _n_y _n_z with
  2025.           a constant pixel value, defined by _d_a_t_a.  The ilConfig object,
  2026.           _c_o_n_f_i_g, (if not NULL) can specify a data type and order for the fill
  2027.           value as well as a channel list or offset.  If _c_o_n_f_i_g specifies an
  2028.           orientation, it is used to map the tile coordinates to the image's
  2029.           orientation.  The _f_i_l_l_M_a_s_k (if not NULL) defines a region within the
  2030.           fill area that is not to be filled; it should be specified in the
  2031.           same orientation as the tile.
  2032.  
  2033.           The _p_a_r_e_n_t MP node (if not NULL) will have this operation added as a
  2034.           dependent node.  The MP manager for this queued operation will be
  2035.           returned via the _p_M_g_r parameter (if not NULL) and can then used to
  2036.           wait for completion, obtain a status code, and/or abort.  For more
  2037.           information on MP synchronization, see the ilMpManager man page.
  2038.  
  2039.  
  2040.  
  2041.  
  2042.                                                                        PPPPaaaaggggeeee 33331111
  2043.  
  2044.  
  2045.  
  2046.  
  2047.  
  2048.  
  2049. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2050.  
  2051.  
  2052.  
  2053.      qqqqFFFFiiiillllllllTTTTiiiilllleeeeRRRRGGGGBBBB(((())))
  2054.  
  2055.           ilStatus qFillTileRGB(ilMpNode* parent, int x, int y, int z,
  2056.                           int nx, int ny, int nz,
  2057.                           float red, float green, float blue,
  2058.                           const iflTile3Dint* fillMask,
  2059.                           iflOrientation orientation, ilMpManager** pMgr);
  2060.  
  2061.  
  2062.           This virtual function should be defined to queue a fill tile request
  2063.           in a manner similar to iiiillllQQQQFFFFiiiillllllllTTTTiiiilllleeee3333DDDD(), except that the fill value
  2064.           is specified with _r_e_d, _g_r_e_e_n, _b_l_u_e pixel components.  The
  2065.           _o_r_i_e_n_t_a_t_i_o_n (if not zero) is used to map the tile and mask
  2066.           coordinates to the image's orientation.
  2067.  
  2068.      qqqqGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD(((())))
  2069.  
  2070.           ilStatus ilQGetSubTile3D(ilMpNode* parent, int x, int y, int z,
  2071.                          int nx, int ny, int nz, void*& data, int dx,
  2072.                          int dy, int dz, int dnx, int dny, int dnz,
  2073.                          const ilConfig* config, ilMpManager** pMgr);
  2074.  
  2075.  
  2076.           This virtual function should be defined by derived classes to queue
  2077.           a read request for an arbitrary rectangular tile of data.  The data
  2078.           should be returned in the buffer pointed to by _d_a_t_a.  The source
  2079.           tile origin is specified by _x, _y, _z, and the tile size is specified
  2080.           by _n_x, _n_y, _n_z.  The destination buffer origin _d_x, _d_y, _d_z and size
  2081.           _d_n_x, _d_n_y, _d_n_z may be different from the source tile; in this case,
  2082.           the source tile will be properly integrated into the destination
  2083.           buffer.
  2084.  
  2085.           The ilConfig object, _c_o_n_f_i_g, may be used to specify the data type,
  2086.           order, number of channels and channel order desired for the buffer.
  2087.           If _c_o_n_f_i_g is NULL then no conversion is performed.  Otherwise, if
  2088.           the configuration specifies attributes different from those of the
  2089.           image, then the data is converted as it is copied into the buffer.
  2090.  
  2091.           The configuration may also include a channel list; it should have as
  2092.           many entries as there are channels in the buffer.  A -1  means no
  2093.           data is written for that channel. For example, if this image has
  2094.           four channels and the number of channels in _c_o_n_f_i_g is 3 and the
  2095.           channel list is (1, -1, 3), then channels 1 and 3 of this image are
  2096.           read into channels 0 and 2 of the buffer in the data type and order
  2097.           specified in _c_o_n_f_i_g. Channel 1 in the buffer remains unchanged. See
  2098.           also the ilConfig man page.
  2099.  
  2100.           The _p_a_r_e_n_t MP node (if not NULL) will have this operation added as a
  2101.           dependent node.  The MP manager for this queued operation will be
  2102.           returned via the _p_M_g_r parameter (if not NULL) and can then used to
  2103.           wait for completion, obtain a status code, and/or abort.  For more
  2104.           information on MP synchronization, see the ilMpManager man page.
  2105.  
  2106.  
  2107.  
  2108.                                                                        PPPPaaaaggggeeee 33332222
  2109.  
  2110.  
  2111.  
  2112.  
  2113.  
  2114.  
  2115. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2116.  
  2117.  
  2118.  
  2119.      qqqqGGGGeeeettttTTTTiiiilllleeee3333DDDD(((())))
  2120.  
  2121.           ilStatus ilQGetTile3D(ilMpNode* parent, int x, int y, int z,
  2122.                            int nx, int ny, int nz, void*& data,
  2123.                            const ilConfig* config, ilMpManager** pMgr)
  2124.  
  2125.  
  2126.           This function calls iiiillllQQQQGGGGeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() with the destination tile
  2127.           position and size equal to that of the source tile.
  2128.  
  2129.      qqqqLLLLoooocccckkkkPPPPaaaaggggeeeeSSSSeeeetttt(((())))
  2130.  
  2131.           ilStatus ilImageQLockPageSet(ilImage *obj, ilMpNode* parent,
  2132.                               ilLockRequest* set, int mode, int count,
  2133.                               ilMpManager** pMgr, ilCallback* perPageCb)
  2134.  
  2135.  
  2136.           This virtual function should be defined by derived classes to queue
  2137.           a request to lock pages in memory.
  2138.  
  2139.           The _s_e_t parameter is a pointer to an array of _c_o_u_n_t ilLockRequest
  2140.           structures:
  2141.  
  2142.                _s_t_r_u_c_t _i_l_L_o_c_k_R_e_q_u_e_s_t : _p_u_b_l_i_c _i_l_X_Y_Z_C_S_i_n_t {
  2143.                    _i_l_S_t_a_t_u_s _s_t_a_t_u_s;
  2144.                    _i_l_P_a_g_e* _p_a_g_e;
  2145.                    _v_o_i_d _i_n_i_t(_i_n_t _X, _i_n_t _Y, _i_n_t _Z, _i_n_t _C);
  2146.                };
  2147.  
  2148.           Each ilLockRequest structure specifies a request for a pointer to
  2149.           the page containing the pixel _X, _Y, _Z, _C.  After the lock request
  2150.           completes each of the _s_t_a_t_u_s codes will be filled in and _p_a_g_e will
  2151.           point at the page containing the requested pixel.  If _s_t_a_t_u_s is not
  2152.           ilOKAY or _X, _Y, _Z, _C references an invalid page, _p_a_g_e will be NULL.
  2153.  
  2154.           The _m_o_d_e parameter is a logical OR of the following mode values:
  2155.  
  2156.                _n_a_m_e           _b_i_t_s     _m_e_a_n_i_n_g
  2157.                _________________________________________________________
  2158.                ilLMpriority   0x0ff    cache priority: 0(low) -> 7(high)
  2159.                ilLMread       0x100    read access
  2160.                ilLMwrite      0x200    write access (mark dirty)
  2161.                ilLMseek       0x400    load into cache without locking
  2162.                ilLMfail       0x800    succeed only if resident
  2163.                ilLMforceMP    0x1000   force MP manager to be created
  2164.  
  2165.           If _m_o_d_e includes ilLMfail, then the status will be set to
  2166.           ilNOTRESIDENT if the page is not resident in cache, instead of
  2167.           forcing the page to be made resident.  See the header file
  2168.           <_i_l/_i_l_E_r_r_o_r._h> for other status values.
  2169.  
  2170.  
  2171.  
  2172.  
  2173.  
  2174.                                                                        PPPPaaaaggggeeee 33333333
  2175.  
  2176.  
  2177.  
  2178.  
  2179.  
  2180.  
  2181. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2182.  
  2183.  
  2184.  
  2185.           In the default implementation in the ilImage base class, copies of
  2186.           pages are returned in locally allocated memory.  Subsequent calls to
  2187.           lock the same pages will return new copies.  This default
  2188.           implementation ignores the _m_o_d_e parameter.  Some derived classes
  2189.           provide more interesting implementations which manage shared cache
  2190.           storage, etc.  One example is ilMemCacheImg.
  2191.  
  2192.           The _p_a_r_e_n_t MP node (if not NULL) will have this operation added as a
  2193.           dependent node.  The MP manager for this queued operation will be
  2194.           returned via the _p_M_g_r parameter (if not NULL) and can then used to
  2195.           wait for completion, obtain a status code, and/or abort.  For more
  2196.           information on MP synchronization, see the ilMpManager man page.
  2197.  
  2198.           Alternatively (or in addition), an ilPage callback, _p_e_r_P_a_g_e_C_b, can
  2199.           be specified; if not NULL, it will be invoked as each page is locked
  2200.           (see the ilPage man page for info on how to declare a paging
  2201.           callback).
  2202.  
  2203.      qqqqSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD(((())))
  2204.  
  2205.           ilStatus ilImageQSetSubTile3D(ilImage *obj, ilMpNode* parent,
  2206.                                                                          int x, int y, int z,  int nx, int ny, int nz,
  2207.                                                                          const void* data, int dx, int dy, int dz,
  2208.                                                                          int dnx, int dny, int dnz,
  2209.                                                                          const ilConfig* config,  ilMpManager** pMgr)
  2210.  
  2211.  
  2212.           This virtual function should be defined by derived classes to queue
  2213.           a request to write an arbitrary tile of data taken from the buffer
  2214.           pointed to by _d_a_t_a.  The image tile origin is specified by _x, _y, _z,
  2215.           and the tile size is specified by _n_x, _n_y, _n_z.  The source buffer's
  2216.           origin _d_x, _d_y, _d_z and size _d_n_x, _d_n_y, _d_n_z may be different from the
  2217.           image tile; in this case, only the intersection of the two tiles is
  2218.           copied.
  2219.  
  2220.           The ilConfig object, _c_o_n_f_i_g, may be used to specify the data type,
  2221.           order, color model, number of channels and channel order of the
  2222.           buffer. If _c_o_n_f_i_g is NULL then no conversion is performed.
  2223.           Otherwise, if the configuration specifies attributes different from
  2224.           those of the image, then the data is converted as it is written to
  2225.           the image.
  2226.  
  2227.           The configuration may also include a channel list; it should have as
  2228.           many entries as there are channels in the buffer.  A -1  means no
  2229.           data is written for that channel. For example, if this image has
  2230.           four channels and the number of channels in _c_o_n_f_i_g is 3 and the
  2231.           channel list is (1, -1, 3), then channels 1 and 3 of this image are
  2232.           read into channels 0 and 2 of the buffer in the data type and order
  2233.           specified in _c_o_n_f_i_g. Channel 1 in the buffer remains unchanged. See
  2234.           also the ilConfig man page.
  2235.  
  2236.  
  2237.  
  2238.  
  2239.  
  2240.                                                                        PPPPaaaaggggeeee 33334444
  2241.  
  2242.  
  2243.  
  2244.  
  2245.  
  2246.  
  2247. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2248.  
  2249.  
  2250.  
  2251.           The _p_a_r_e_n_t MP node (if not NULL) will have this operation added as a
  2252.           dependent node.  The MP manager for this queued operation will be
  2253.           returned via the _p_M_g_r parameter (if not NULL) and can then used to
  2254.           wait for completion, obtain a status code, and/or abort.  For more
  2255.           information on MP synchronization, see the ilMpManager man page.
  2256.  
  2257.           This is a virtual function and should be defined by derived classes.
  2258.           See also sssseeeettttTTTTiiiilllleeee(), and iiiillllGGGGeeeettttCCCCoooonnnnffffiiiigggg().
  2259.  
  2260.      qqqqSSSSeeeettttTTTTiiiilllleeee3333DDDD(((())))
  2261.  
  2262.           ilStatus ilImageQSetTile3D(ilImage *obj, ilMpNode* parent,
  2263.                                      int x, int y, int z, int nx,
  2264.                                      int ny, int nz, void* data,
  2265.                                      const ilConfig* config, ilMpManager** pMgr)
  2266.  
  2267.  
  2268.           This function is a call-through to iiiillllQQQQSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() with the buffer
  2269.           tile position and size equal to the image tile position and size.
  2270.  
  2271.      rrrreeeemmmmoooovvvveeeeIIIInnnnppppuuuutttt(((())))
  2272.  
  2273.           ilStatus ilRemoveInput(ilImage *img, int idx)
  2274.  
  2275.  
  2276.           Removes the image at index _i_d_x from the input (parent) list. If
  2277.           successful, ilOKAY is returned. The default index is 0.
  2278.  
  2279.      sssseeeettttCCCCoooolllloooorrrrmmmmaaaapppp(((())))
  2280.  
  2281.           ilStatus ilSetColormap(ilImage *img, iflColormap *cmap)
  2282.  
  2283.  
  2284.           Sets the image's color map to the given iflColormap.  If successful,
  2285.           ilOKAY is returned.  See also iiiillllGGGGeeeettttCCCCoooolllloooorrrrmmmmaaaapppp() and iiiillllGGGGeeeettttCCCCoooolllloooorrrrMMMMaaaappppPPPPttttrrrr()
  2286.           and iflColormap.
  2287.  
  2288.      sssseeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll(((())))
  2289.  
  2290.           ilStatus ilSetColorModel(ilImage *img, iflColorModel c)
  2291.  
  2292.  
  2293.           Sets the image's color model to the enumerated type, _i_f_l_C_o_l_o_r_M_o_d_e_l,
  2294.           specified by _c. If successful, ilOKAY is returned.  See also
  2295.           iiiillllGGGGeeeettttCCCCoooolllloooorrrrMMMMooooddddeeeellll().
  2296.  
  2297.  
  2298.  
  2299.  
  2300.  
  2301.  
  2302.  
  2303.  
  2304.  
  2305.  
  2306.                                                                        PPPPaaaaggggeeee 33335555
  2307.  
  2308.  
  2309.  
  2310.  
  2311.  
  2312.  
  2313. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2314.  
  2315.  
  2316.  
  2317.      sssseeeettttCCCCoooommmmpppprrrreeeessssssssiiiioooonnnn(((())))
  2318.  
  2319.           ilStatus ilSetCompression(ilImage *img, iflCompression c)
  2320.  
  2321.  
  2322.           Sets the image's compression scheme to the enumerated type,
  2323.           _i_f_l_C_o_m_p_r_e_s_s_i_o_n, specified by _c.  If successful, ilOKAY is returned.
  2324.           See also iiiillllGGGGeeeettttCCCCoooommmmpppprrrreeeessssssssiiiioooonnnn().
  2325.  
  2326.      sssseeeettttOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn(((())))
  2327.  
  2328.           ilStatus ilSetOrientation(ilImage *img, iflOrientation spc)
  2329.  
  2330.  
  2331.           Sets the image's orientation to the enumerated type, _i_f_l_O_r_i_e_n_t_a_t_i_o_n,
  2332.           specified by _s_p_c. This parameter determines whether the image origin
  2333.           is, for example, the upper left corner or the lower left corner. See
  2334.           also iiiillllGGGGeeeettttOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn().
  2335.  
  2336.      sssseeeettttCCCCssssiiiizzzzeeee(((())))
  2337.  
  2338.           ilStatus ilSetCsize(ilImage *img, int nc)
  2339.           ilStatus ilSetNumChans(ilImage *img, int nc)
  2340.  
  2341.  
  2342.           Sets the number of channels in the image. Each pixel has _n_c channels
  2343.           or components. Returns ilOKAY upon successful completion.
  2344.  
  2345.      sssseeeettttDDDDaaaattttaaaaTTTTyyyyppppeeee(((())))
  2346.  
  2347.           ilStatus ilSetDataType(ilImage *img, iflDataType dtype)
  2348.  
  2349.  
  2350.           Sets the image data type to the enumerated type, _i_f_l_D_a_t_a_T_y_p_e,
  2351.           specified by _d_t_y_p_e. Returns ilOKAY upon successful completion.
  2352.  
  2353.      sssseeeettttFFFFiiiillllllll(((())))
  2354.  
  2355.           ilStatus ilSetFill(ilImage *img, iflPixel *pixel)
  2356.  
  2357.  
  2358.           Sets the image's fill value data member to the values in _p_i_x_e_l.
  2359.           When iiiillllGGGGeeeettttTTTTiiiilllleeee() or iiiillllCCCCooooppppyyyyTTTTiiiilllleeee() try to access pixels that are
  2360.           beyond the image's edge, those pixels are set to the fill value.
  2361.           The iflPixel type is defined in its header file as consisting of an
  2362.           iflDataType that defines the data type of the image's pixels, an iiiinnnntttt
  2363.           specifying the number of channels of data, and a pointer to the
  2364.           actual pixel data.  See also iiiillllGGGGeeeettttFFFFiiiillllllll() and iiiillllCCCClllliiiippppTTTTiiiilllleeee().
  2365.  
  2366.  
  2367.  
  2368.  
  2369.  
  2370.  
  2371.  
  2372.                                                                        PPPPaaaaggggeeee 33336666
  2373.  
  2374.  
  2375.  
  2376.  
  2377.  
  2378.  
  2379. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2380.  
  2381.  
  2382.  
  2383.      sssseeeettttFFFFiiiillllllllRRRRGGGGBBBB(((())))
  2384.  
  2385.           ilStatus ilSetFillRGB(ilImage *img, float red, float green, float blue)
  2386.  
  2387.  
  2388.           Sets the image fill value to a pixel whose elements will be
  2389.           interpreted as the color indicated by _r_e_d, _g_r_e_e_n and _b_l_u_e.  The
  2390.           values for the color triplet should be in the range from zero to
  2391.           one.  See also iiiillllSSSSeeeettttFFFFiiiillllllll().  sssseeeettttFFFFiiiillllllllVVVVaaaalllluuuueeee(((())))
  2392.  
  2393.           ilStatus ilSetFillValue(ilImage *img, double val, int c)
  2394.  
  2395.  
  2396.           Sets the image fill value for channel _c to _v_a_l.  See also
  2397.           iiiillllSSSSeeeettttFFFFiiiillllllll().
  2398.  
  2399.      sssseeeettttHHHHwwwwEEEEnnnnaaaabbbblllleeee(((())))
  2400.  
  2401.           void ilSetHwEnable(ilImage *obj, ilHwAccelEnable enable)
  2402.  
  2403.  
  2404.           This function enables or disables hardware acceleration for this
  2405.           image object.  If acceleration is successfully enabled, the image
  2406.           will derive a performance improvement by using the installed
  2407.           graphics hardware of the system.  See the man page for
  2408.           _i_l_H_w_A_c_c_e_l_e_r_a_t_e.
  2409.  
  2410.      sssseeeettttIIIInnnnppppuuuutttt(((())))
  2411.  
  2412.           ilStatus ilSetInput(ilImage *img, ilImage *inimg, int idx)
  2413.  
  2414.  
  2415.           Inserts the image _i_n_i_m_g into the input (parent) list at index _i_d_x.
  2416.           Returns ilOKAY upon successful completion.  See also iiiillllAAAAddddddddIIIInnnnppppuuuutttt().
  2417.  
  2418.      sssseeeettttMMMMaaaaxxxxCCCCoooolllloooorrrrmmmmaaaappppLLLLeeeevvvveeeellllssss(((())))
  2419.  
  2420.           void ilSetMaxColormapLevels(int maxLevels)
  2421.  
  2422.  
  2423.           This function sets the maximum number of color levels for optimal
  2424.           color map generation for this image object.  This value may be used
  2425.           to generate a color map when displaying the image if an explicit
  2426.           color map is not supplied.
  2427.  
  2428.  
  2429.  
  2430.  
  2431.  
  2432.  
  2433.  
  2434.  
  2435.  
  2436.  
  2437.  
  2438.                                                                        PPPPaaaaggggeeee 33337777
  2439.  
  2440.  
  2441.  
  2442.  
  2443.  
  2444.  
  2445. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2446.  
  2447.  
  2448.  
  2449.      sssseeeettttMMMMaaaaxxxxVVVVaaaalllluuuueeee(((())))
  2450.  
  2451.           ilStatus ilSetMaxValue(ilImage *img, double val)
  2452.  
  2453.  
  2454.           Sets the maximum allowable value for all channels.
  2455.  
  2456.      sssseeeettttMMMMiiiinnnnVVVVaaaalllluuuueeee(((())))
  2457.  
  2458.           ilStatus ilSetMinValue(ilImage *img, double val)
  2459.  
  2460.  
  2461.           Sets the minimum allowable value for all channels.
  2462.  
  2463.      sssseeeettttOOOOrrrrddddeeeerrrr(((())))
  2464.  
  2465.           ilStatus ilSetOrder(ilImage *img, iflOrder order)
  2466.  
  2467.  
  2468.           Sets the pixel channel order of this image to _o_r_d_e_r. The enumerated
  2469.           type, _i_f_l_O_r_d_e_r can be one of _i_l_I_n_t_e_r_l_e_a_v_e_d, _i_l_S_e_q_u_e_n_t_i_a_l or
  2470.           _i_l_S_e_p_a_r_a_t_e.  Returns ilOKAY upon successful completion. See also
  2471.           iiiillllGGGGeeeettttOOOOrrrrddddeeeerrrr().
  2472.  
  2473.      sssseeeettttPPPPaaaaggggeeeeBBBBoooorrrrddddeeeerrrr(((())))
  2474.  
  2475.           ilStatus ilSetPageBorderStruct(ilImage *img, const iflXYZint *border)
  2476.           ilStatus ilSetPageBorder(ilImage *img, int nx, int ny, int nz)
  2477.  
  2478.  
  2479.           Sets the current page border size to _n_x, _n_y, _n_z.
  2480.  
  2481.      sssseeeettttPPPPaaaaggggeeeeSSSSiiiizzzzeeee(((())))
  2482.  
  2483.           ilStatus ilSetPageSizeStruct(ilImage *img, const iflSize *pageSize)
  2484.           ilStatus ilSetPageSize(ilImage *img, int nx, int ny, int nz,
  2485.                                  int nc)
  2486.           ilStatus ilSetPageSizeXY(ilImage *img, int nx, int ny)
  2487.           ilStatus ilSetPageSizeZ(int nz)
  2488.           ilStatus ilSetPageSizeC(int nc)
  2489.  
  2490.  
  2491.           Functions to set the page size.  For each of the versions of this
  2492.           function, the x size is set to _n_x, the y size is set to _n_y, the z
  2493.           size is set to _n_z, and the number of channels is set to _n_c.  See
  2494.           also ilCacheImg.
  2495.  
  2496.  
  2497.  
  2498.  
  2499.  
  2500.  
  2501.  
  2502.  
  2503.  
  2504.                                                                        PPPPaaaaggggeeee 33338888
  2505.  
  2506.  
  2507.  
  2508.  
  2509.  
  2510.  
  2511. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2512.  
  2513.  
  2514.  
  2515.      sssseeeettttPPPPiiiixxxxeeeellll(((())))
  2516.  
  2517.           ilStatus ilSetPixel(ilImage *img, int x, int y, iflPixel *pix)
  2518.  
  2519.  
  2520.           This function is the 2-D version of iiiillllSSSSeeeettttPPPPiiiixxxxeeeellll3333DDDD().  It calls
  2521.           iiiillllSSSSeeeettttPPPPiiiixxxxeeeellll3333DDDD() with _z set to 0.
  2522.  
  2523.      sssseeeettttPPPPiiiixxxxeeeellll3333DDDD(((())))
  2524.  
  2525.           ilStatus ilSetPixel3D(ilImage *img, int x, int y, int z,
  2526.                                 iflPixel *pix)
  2527.  
  2528.  
  2529.           Writes the iflPixel specified by _p_i_x to the location specified by _x,
  2530.           _y, and _z.  An iflPixel specifies the channel data type, the number
  2531.           of channels per pixel and a pointer to the pixel data.  This
  2532.           function calls iiiillllSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() with the tile size _n_x, _n_y and _n_z set
  2533.           to 1. Returns ilOKAY upon successful completion. See also
  2534.           iiiillllGGGGeeeettttPPPPiiiixxxxeeeellll3333DDDD() and iiiillllSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD(), iiiillllSSSSeeeettttPPPPiiiixxxxeeeellll().
  2535.  
  2536.      sssseeeettttPPPPrrrriiiioooorrrriiiittttyyyy(((())))
  2537.  
  2538.           void ilSetPriority(ilImage *img, int pri)
  2539.  
  2540.  
  2541.           This function sets the cache priority of this image, the default is
  2542.           zero (the lowest priority).  By setting a larger value (up to the
  2543.           maximum of 7), the likelihood that this image's pages will stay in
  2544.           the global cache is increased.
  2545.  
  2546.      sssseeeettttSSSSccccaaaalllleeeeMMMMiiiinnnnMMMMaaaaxxxx(((())))
  2547.  
  2548.           ilStatus ilSetScaleMinMax(ilImage *img, double min, double max)
  2549.  
  2550.  
  2551.           Sets the scale minimum and maximum to _m_i_n and _m_a_x.  The scale
  2552.           minimum and maximum are used during color conversion and display.
  2553.           By default, the scale minimum and maximum track the image minimum
  2554.           and maximum values.
  2555.  
  2556.      sssseeeettttSSSSccccaaaalllleeeeTTTTyyyyppppeeee(((())))
  2557.  
  2558.           ilStatus ilSetScaleType(ilImage *img, iflDataType type)
  2559.  
  2560.  
  2561.           Sets the scale minimum and maximum to the minimum and maximum values
  2562.           of the data type passed in _t_y_p_e.  If _t_y_p_e is defaulted, then this
  2563.           object's data type is used.  The scale minimum and maximum are used
  2564.           during color conversion.  By default, the scale minimum and maximum
  2565.           track the image minimum and maximum values.
  2566.  
  2567.  
  2568.  
  2569.  
  2570.                                                                        PPPPaaaaggggeeee 33339999
  2571.  
  2572.  
  2573.  
  2574.  
  2575.  
  2576.  
  2577. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2578.  
  2579.  
  2580.  
  2581.      sssseeeettttSSSSiiiizzzzeeee(((())))
  2582.  
  2583.           ilStatus ilSetSize(ilImage *img, iflSize *size)
  2584.           ilStatus ilSetXYsize(ilImage *img, int nx, int ny)
  2585.  
  2586.  
  2587.           Sets the image size to the value referenced by _s_i_z_e.  The second
  2588.           versions allows just the _x and _y size to be set.  Returns ilOKAY
  2589.           upon successful completion. See also iiiillllGGGGeeeettttSSSSiiiizzzzeeee().
  2590.  
  2591.      sssseeeettttTTTTiiiilllleeee(((())))
  2592.  
  2593.           ilStatus ilSetTile(ilImage *img, int x, int y, int nx, int ny,
  2594.                        const void *data, ilConfig *config)
  2595.           ilStatus ilSetSubTile(ilImage *img, int x, int y, int nx, int ny,
  2596.                           const void *data, int dx, int dy, int dnx, int dny,
  2597.                           ilConfig *config)
  2598.           ilStatus ilSetSubTile3D(ilImage *img, int x, int y, int z,
  2599.                          int nx, int ny, int nz, const void *data,
  2600.                          int dx, int dy, int dz, int dnx,
  2601.                                   int dny, int dnz, ilConfig *config)
  2602.           ilStatus ilSetTile3D(ilImage *img, int x, int y, int z,
  2603.                          int nx, int ny, int nz,
  2604.                          const void *data, ilConfig *config)
  2605.  
  2606.  
  2607.           These functions queue a tile write request with iiiillllQQQQSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD()
  2608.           and wait for it to complete.  The source tile origin is specified by
  2609.           _x, _y, _z, and the tile size is specified by _n_x, _n_y, _n_z.
  2610.  
  2611.           The 2D versions, iiiillllSSSSeeeettttTTTTiiiilllleeee() and iiiillllSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee(), call the
  2612.           corresponding 3D routine with _z set to zero and _n_z set to one.
  2613.  
  2614.           iiiillllSSSSeeeettttTTTTiiiilllleeee() and iiiillllSSSSeeeettttTTTTiiiilllleeee3333DDDD() assume that the source buffer has the
  2615.           same offset and size as the request; iiiillllSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee() and
  2616.           iiiillllSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() allow the source buffer to have a different
  2617.           position and size, specified by _d_x, _d_y, _d_n_x, and _d_n_y (and _d_z and _d_n_z
  2618.           for the 3D version.)
  2619.  
  2620.           See also iiiillllQQQQSSSSeeeettttTTTTiiiilllleeee3333DDDD(), iiiillllQQQQSSSSeeeettttSSSSuuuubbbbTTTTiiiilllleeee3333DDDD() and iiiillllGGGGeeeettttCCCCoooonnnnffffiiiigggg().
  2621.           sssseeeettttWWWWrrrriiiittttaaaabbbblllleeee(((())))
  2622.  
  2623.           void setWritable(int enable=TRUE)  _p_r_o_t_e_c_t_e_d
  2624.  
  2625.  
  2626.           This function will enable or disable write access to this image.  If
  2627.           _e_n_a_b_l_e is TRUE, then the image will be writable; if FALSE, then the
  2628.           image is not writable.
  2629.  
  2630.  
  2631.  
  2632.  
  2633.  
  2634.  
  2635.  
  2636.                                                                        PPPPaaaaggggeeee 44440000
  2637.  
  2638.  
  2639.  
  2640.  
  2641.  
  2642.  
  2643. iiiillllIIIImmmmaaaaggggeeee((((3333))))         IIIImmmmaaaaggggeeeeVVVViiiissssiiiioooonnnn LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll         iiiillllIIIImmmmaaaaggggeeee((((3333))))
  2644.  
  2645.  
  2646.  
  2647.      sssseeeettttXXXXssssiiiizzzzeeee(((())))
  2648.  
  2649.           ilStatus ilSetXsize(ilImage *img, int nx)
  2650.  
  2651.  
  2652.           Sets the size of the image in the _x-dimension, measured in pixels.
  2653.           Returns ilOKAY upon successful completion.  See special notes on IL
  2654.           image memory order conventions and orientations in the description
  2655.           of ilGetXsize().
  2656.  
  2657.      sssseeeettttYYYYssssiiiizzzzeeee(((())))
  2658.  
  2659.           ilStatus ilSetYsize(ilImage *img, int ny)
  2660.  
  2661.  
  2662.           Sets the size of the image in the _y-dimension, measured in pixels.
  2663.           Returns ilOKAY upon successful completion.
  2664.  
  2665.      sssseeeettttZZZZssssiiiizzzzeeee(((())))
  2666.  
  2667.           ilStatus ilSetZsize(ilImage *img, int nz)
  2668.  
  2669.  
  2670.           Sets the size of the image in the _z-dimension, measured in pixels.
  2671.           Returns ilOKAY upon successful completion.
  2672.  
  2673. IIIINNNNHHHHEEEERRRRIIIITTTTEEEEDDDD MMMMEEEEMMMMBBBBEEEERRRR FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS
  2674.    IIIInnnnhhhheeeerrrriiiitttteeeedddd ffffrrrroooommmm iiiillllLLLLiiiinnnnkkkk
  2675.      ilLinkClearSet(), ilLinkClearStatus(), ilLinkGetDescription(),
  2676.      ilLinkGetDirectParent(), ilLinkGetDisabledIndex(), ilLinkGetFloatProp(),
  2677.      ilLinkGetGenerationID(), ilLinkGetIntProp(), ilLinkGetNumChildren(),
  2678.      ilLinkGetNumParents(), ilLinkGetParent(), ilLinkGetPtrProp(),
  2679.      ilLinkGetRelatedChild(), ilLinkGetRelatedDelete(),
  2680.      ilLinkGetRelatedType(), ilLinkGetStatus(), ilLinkIsAllowed(),
  2681.      ilLinkIsAltered(), ilLinkIsEnabled(), ilLinkIsRelated(), ilLinkIsSet(),
  2682.      ilLinkRemoveParent(), ilLinkRemoveProp(), ilLinkSetDescription(),
  2683.      ilLinkSetDisabledIndex(), ilLinkSetEnabled(), ilLinkSetParent(),
  2684.      ilLinkSetProp(), ilLinkSetRelatedDelete(), ilLinkSetRelatedType()
  2685.  
  2686. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  2687.      ilCacheImg, ilDisplayImg, ilFileImg, iflColormap, ilMemoryImg, ilOpImg,
  2688.      ilSubImg, _i_l/_i_l_I_m_a_g_e._h, _i_f_l/_i_f_l_D_a_t_a_T_y_p_e_s._h
  2689.  
  2690.      Please refer to the _I_m_a_g_e_V_i_s_i_o_n _L_i_b_r_a_r_y _P_r_o_g_r_a_m_m_i_n_g _G_u_i_d_e for a full
  2691.      description of overall concepts and architecture.
  2692.  
  2693. NNNNOOOOTTTTEEEESSSS
  2694.      Although the ilImage class contains no pure virtual functions, it should
  2695.      only be used to derive new classes, never directly created as an object.
  2696.      However, a pointer to an ilImage can be declared in order to support
  2697.      polymorphism.
  2698.  
  2699.  
  2700.  
  2701.  
  2702.                                                                        PPPPaaaaggggeeee 44441111
  2703.  
  2704.  
  2705.  
  2706.